using System;
using System.Collections.Generic;
using Oracle.ManagedDataAccess.Client;
using Oracle.ManagedDataAccess.Types;
using OracleInternal.Common;
using OracleInternal.Core;
using OracleInternal.TTC;
using OracleInternal.TTC.Accessors;

namespace OracleInternal.ServiceObjects
{
	internal class OracleParameterImpl
	{
		internal byte[] m_paramValInBytes;

		internal byte[][] m_paramValForArrayBindInBytes;

		internal const byte InvalidPrecision = 100;

		internal const byte InvalidScale = 129;

		internal byte m_precision = 100;

		internal byte m_scale = 129;

		internal int m_curSize;

		internal int[] m_curArrayBindSize;

		internal OracleParameterStatus[] m_arrayBindStatus;

		internal OracleParameterStatus m_status;

		internal object[] m_saveValue;

		internal byte[] m_qLocatorData;

		internal byte[][] m_qLocatorDataForArrayBind;

		internal bool m_bSkipConversionToLocalTime;

		internal OracleParameterImpl()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ctor);
			}
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ctor);
			}
		}

		private object ExtractDecimalFromAccessor(Accessor accessor, PrmEnumType enumType, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractDecimalFromAccessor);
			}
			try
			{
				TTCNumberAccessor obj = accessor as TTCNumberAccessor;
				object obj2 = null;
				byte[] byteRepresentation = obj.GetByteRepresentation(currentRow);
				if (m_precision != 100 || m_scale != 129)
				{
					OracleDecimal value = new OracleDecimal(byteRepresentation, bContainsLength: false);
					OracleDecimal oracleDecimal = OracleDecimal.Null;
					if (m_precision != 100 && m_scale != 129)
					{
						oracleDecimal = OracleDecimal.ConvertToPrecScale(value, m_precision, m_scale);
					}
					else if (m_precision != 100)
					{
						oracleDecimal = OracleDecimal.SetPrecision(value, m_precision);
					}
					else if (m_scale != 129)
					{
						oracleDecimal = OracleDecimal.AdjustScale(value, m_scale, fRound: true);
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						return oracleDecimal;
					}
					return oracleDecimal.Value;
				}
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					return new OracleDecimal(byteRepresentation, bContainsLength: false);
				}
				return DecimalConv.GetDecimal(byteRepresentation, 0, byteRepresentation.Length);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractDecimalFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractDecimalFromAccessor);
				}
			}
		}

		private object ExtractDoubleFromAccessor(Accessor accessor, PrmEnumType enumType, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractDoubleFromAccessor);
			}
			try
			{
				TTCNumberAccessor obj = accessor as TTCNumberAccessor;
				object obj2 = null;
				obj2 = obj.GetDouble(currentRow);
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					obj2 = new OracleDecimal((double)obj2);
				}
				return obj2;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractDoubleFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractDoubleFromAccessor);
				}
			}
		}

		private object ExtractSingleFromAccessor(Accessor accessor, PrmEnumType enumType, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractSingleFromAccessor);
			}
			try
			{
				TTCNumberAccessor tTCNumberAccessor = accessor as TTCNumberAccessor;
				object obj = null;
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					return new OracleDecimal(OracleNumberCore.lnxfpr(tTCNumberAccessor.GetByteRepresentation(currentRow), 7), bContainsLength: false);
				}
				return tTCNumberAccessor.GetFloat(currentRow);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractSingleFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractSingleFromAccessor);
				}
			}
		}

		private object ExtractIntFromAccessor(Accessor accessor, PrmEnumType enumType, OracleDbType oraDbType, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractIntFromAccessor);
			}
			try
			{
				TTCNumberAccessor tTCNumberAccessor = accessor as TTCNumberAccessor;
				object obj = null;
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					obj = new OracleDecimal(tTCNumberAccessor.GetByteRepresentation(currentRow), bContainsLength: false);
				}
				else
				{
					obj = tTCNumberAccessor.GetInt(currentRow);
					switch (oraDbType)
					{
					case OracleDbType.Int16:
						obj = Convert.ToInt16(obj);
						break;
					case OracleDbType.Byte:
						obj = Convert.ToByte(obj);
						break;
					}
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractIntFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractIntFromAccessor);
				}
			}
		}

		private object ExtractRefCursorFromAccessor(OracleConnection conn, Accessor accessor, long fetchSize, PrmEnumType enumType, OracleIntervalDS sessionTimeZone, string commandText, string paramPosOrName, long longFetchSize, long clientInitialLOBFS, long internalInitialLOBFS, long internalInitialJSONFS, long[] scnFromExecution, int currentRow, bool bCallFromExecuteReader)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractRefCursorFromAccessor);
			}
			try
			{
				TTCRefCursorAccessor obj = accessor as TTCRefCursorAccessor;
				object obj2 = null;
				OracleRefCursorImpl oracleRefCursorImpl = new OracleRefCursorImpl(obj.GetResultSet(currentRow));
				OracleRefCursor oracleRefCursor = new OracleRefCursor(conn, oracleRefCursorImpl, sessionTimeZone, commandText, paramPosOrName, longFetchSize, clientInitialLOBFS, internalInitialLOBFS, internalInitialJSONFS, scnFromExecution);
				if (fetchSize > 0)
				{
					oracleRefCursor.FetchSize = fetchSize;
				}
				if (oracleRefCursorImpl.m_sqlMetaData != null && oracleRefCursorImpl.m_sqlMetaData.m_maxRowSize == 0)
				{
					oracleRefCursorImpl.m_sqlMetaData.CalculateRowSize();
				}
				if (bCallFromExecuteReader || PrmEnumType.ORADBTYPE == enumType)
				{
					obj2 = oracleRefCursor;
				}
				else
				{
					obj2 = oracleRefCursor.GetDataReader(fillRequest: false);
					oracleRefCursor.Dispose();
				}
				return obj2;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractRefCursorFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractRefCursorFromAccessor);
				}
			}
		}

		private object ExtractLongFromAccessor(object accessor, PrmEnumType enumType, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractLongFromAccessor);
			}
			try
			{
				TTCNumberAccessor obj = accessor as TTCNumberAccessor;
				object obj2 = null;
				byte[] byteRepresentation = obj.GetByteRepresentation(currentRow);
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					return new OracleDecimal(byteRepresentation, bContainsLength: false);
				}
				return OracleNumberCore.lnxsni(byteRepresentation);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractLongFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractLongFromAccessor);
				}
			}
		}

		private object ExtractBDoubleFromAccessor(Accessor accessor, PrmEnumType enumType, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractBDoubleFromAccessor);
			}
			try
			{
				TTCBinaryDoubleAccessor tTCBinaryDoubleAccessor = accessor as TTCBinaryDoubleAccessor;
				object obj = null;
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					return new OracleDecimal(tTCBinaryDoubleAccessor.GetValue(currentRow));
				}
				return tTCBinaryDoubleAccessor.GetValue(currentRow);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractBDoubleFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractBDoubleFromAccessor);
				}
			}
		}

		private object ExtractBFloatFromAccessor(Accessor accessor, PrmEnumType enumType, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractBFloatFromAccessor);
			}
			try
			{
				TTCBinaryFloatAccessor tTCBinaryFloatAccessor = accessor as TTCBinaryFloatAccessor;
				object obj = null;
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					return new OracleDecimal(tTCBinaryFloatAccessor.GetValue(currentRow));
				}
				return tTCBinaryFloatAccessor.GetValue(currentRow);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractBFloatFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractBFloatFromAccessor);
				}
			}
		}

		private object ExtractCharFromAccessor(Accessor accessor, PrmEnumType enumType, byte charSetForm, int maxSizeRequested, int currentRow, char[] charArrayFromPooler, out int length)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractCharFromAccessor);
			}
			try
			{
				TTCVarcharAccessor tTCVarcharAccessor = accessor as TTCVarcharAccessor;
				string text = string.Empty;
				object obj = null;
				if (maxSizeRequested > 0)
				{
					text = tTCVarcharAccessor.GetString(currentRow, charSetForm, charArrayFromPooler);
					if (maxSizeRequested < text.Length)
					{
						text = text.Substring(0, maxSizeRequested);
					}
				}
				obj = ((PrmEnumType.ORADBTYPE != enumType) ? text : ((object)new OracleString(text)));
				length = text.Length;
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractCharFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractCharFromAccessor);
				}
			}
		}

		private object ExtractRawFromAccessor(Accessor accessor, PrmEnumType enumType, int maxLength, int currentRow, out int length)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractRawFromAccessor);
			}
			try
			{
				TTCRawAccessor tTCRawAccessor = accessor as TTCRawAccessor;
				object obj = null;
				byte[] array = new byte[0];
				if (maxLength > 0)
				{
					array = tTCRawAccessor.GetByteRepresentation(currentRow);
					if (maxLength < array.Length)
					{
						Array.Resize(ref array, maxLength);
					}
				}
				obj = ((PrmEnumType.ORADBTYPE != enumType) ? array : ((object)new OracleBinary(array, bCopy: false)));
				length = array.Length;
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractRawFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractRawFromAccessor);
				}
			}
		}

		private object ExtractDateFromAccessor(Accessor accessor, PrmEnumType enumType, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractDateFromAccessor);
			}
			try
			{
				TTCDateTimeAccessor tTCDateTimeAccessor = accessor as TTCDateTimeAccessor;
				object obj = null;
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					return new OracleDate(tTCDateTimeAccessor.GetByteRepresentation(currentRow));
				}
				return tTCDateTimeAccessor.GetDateTime(currentRow);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractDateFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractDateFromAccessor);
				}
			}
		}

		private object ExtractTimeStampFromAccessor(Accessor accessor, PrmEnumType enumType, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractTimeStampFromAccessor);
			}
			try
			{
				TTCDateTimeAccessor tTCDateTimeAccessor = accessor as TTCDateTimeAccessor;
				object obj = null;
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					return new OracleTimeStamp(tTCDateTimeAccessor.GetByteRepresentation(currentRow));
				}
				return tTCDateTimeAccessor.GetDateTime(currentRow);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractTimeStampFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractTimeStampFromAccessor);
				}
			}
		}

		private object ExtractTimeStampTZFromAccessor(Accessor accessor, PrmEnumType enumType, int currentRow, OracleConnectionImpl connImpl, bool asDateTimeOffset = false)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractTimeStampTZFromAccessor);
			}
			try
			{
				TTCDateTimeAccessor obj = accessor as TTCDateTimeAccessor;
				object obj2 = null;
				byte[] byteRepresentation = obj.GetByteRepresentation(currentRow);
				if (!m_bSkipConversionToLocalTime && connImpl.IsTZDataSentAsLocalTime)
				{
					byte[] utcArray = null;
					DateTime? dateObj = null;
					TimeStamp.GetUTCByteRepFromLocalArray(byteRepresentation, out utcArray, out dateObj);
					obj2 = new OracleTimeStampTZ(utcArray);
				}
				else
				{
					obj2 = new OracleTimeStampTZ(byteRepresentation);
				}
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					return obj2;
				}
				TimeSpan timeZoneOffset = ((OracleTimeStampTZ)obj2).GetTimeZoneOffset();
				obj2 = ((OracleTimeStampTZ)obj2).Value;
				if (asDateTimeOffset && obj2 != null)
				{
					obj2 = new DateTimeOffset((DateTime)obj2, timeZoneOffset);
				}
				return obj2;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractTimeStampTZFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractTimeStampTZFromAccessor);
				}
			}
		}

		private object ExtractTimeStampLTZFromAccessor(Accessor accessor, PrmEnumType enumType, OracleConnectionImpl connImpl, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractTimeStampLTZFromAccessor);
			}
			try
			{
				TTCDateTimeAccessor obj = accessor as TTCDateTimeAccessor;
				object obj2 = null;
				DateTime? dateObj = null;
				byte[] byteRepresentation = obj.GetByteRepresentation(currentRow);
				if (byteRepresentation != null)
				{
					byte[] byteRep = null;
					TimeStamp.ConvertDBTimeToLTZData(byteRepresentation, connImpl.GetDBTimeZoneBytes(), connImpl.m_sessionTimeZone, out byteRep, out dateObj);
					obj2 = new OracleTimeStampLTZ(byteRep, bCopyData: false);
				}
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					return obj2;
				}
				return ((OracleTimeStampLTZ)obj2).Value;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractTimeStampLTZFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractTimeStampLTZFromAccessor);
				}
			}
		}

		private object ExtractIntervalYMFromAccessor(Accessor accessor, PrmEnumType enumType, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractIntervalYMFromAccessor);
			}
			try
			{
				TTCIntervalTypeAccessor obj = accessor as TTCIntervalTypeAccessor;
				object obj2 = null;
				byte[] byteRepresentation = obj.GetByteRepresentation(currentRow);
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					return new OracleIntervalYM(byteRepresentation);
				}
				return OracleIntervalYM.GetLong(byteRepresentation, OracleDbType.IntervalYM);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractIntervalYMFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractIntervalYMFromAccessor);
				}
			}
		}

		private object ExtractIntervalDSFromAccessor(Accessor accessor, PrmEnumType enumType, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractIntervalDSFromAccessor);
			}
			try
			{
				TTCIntervalTypeAccessor obj = accessor as TTCIntervalTypeAccessor;
				object obj2 = null;
				byte[] byteRepresentation = obj.GetByteRepresentation(currentRow);
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					return new OracleIntervalDS(byteRepresentation);
				}
				return OracleIntervalDS.GetTimeSpan(byteRepresentation, OracleDbType.IntervalDS);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractIntervalDSFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractIntervalDSFromAccessor);
				}
			}
		}

		internal ColumnDescribeInfo GetParameterMetaData(OracleParameter parameter, ColumnDescribeInfo cachedParamMetadata, ref bool bMetadataModified)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetParameterMetaData);
			}
			ColumnDescribeInfo columnDescribeInfo = null;
			try
			{
				if (!bMetadataModified && cachedParamMetadata == null)
				{
					columnDescribeInfo = ((cachedParamMetadata != null) ? cachedParamMetadata : new ColumnDescribeInfo());
					if (!parameter.m_bDuplicateBind)
					{
						columnDescribeInfo.m_flag = 3;
					}
					else
					{
						columnDescribeInfo.m_flag = 128;
					}
					if (parameter.CollectionType == OracleCollectionType.PLSQLAssociativeArray)
					{
						columnDescribeInfo.m_flag |= 64;
					}
					if (parameter.CollectionType == OracleCollectionType.PLSQLAssociativeArray)
					{
						columnDescribeInfo.m_maxNoOfArrayElements = parameter.m_maxNoOfArrayElements;
					}
					else
					{
						columnDescribeInfo.m_maxNoOfArrayElements = 0;
					}
					columnDescribeInfo.m_dataType = (short)parameter.m_oraType;
					columnDescribeInfo.m_precision = 0;
					columnDescribeInfo.m_scale = 0;
					if (parameter.m_oraType == OraType.ORA_CHAR || parameter.m_oraType == OraType.ORA_CHARN || parameter.m_oraType == OraType.ORA_VARCHAR)
					{
						columnDescribeInfo.m_contFlag = 16L;
					}
					else
					{
						columnDescribeInfo.m_contFlag = 0L;
					}
					columnDescribeInfo.m_maxLength = parameter.m_maxBytesToBeWrittenOrRead;
					if (parameter.m_oraType == OraType.ORA_INTY)
					{
						columnDescribeInfo.bIsXmlType = true;
						columnDescribeInfo.m_toid = TTCXmlTypePickler.TOID;
						columnDescribeInfo.m_version = 1;
						columnDescribeInfo.m_characterSetId = 2;
					}
					else
					{
						columnDescribeInfo.m_toid = null;
						columnDescribeInfo.m_version = 0;
						columnDescribeInfo.m_characterSetId = parameter.m_characterSetId;
					}
					columnDescribeInfo.m_characterSetForm = parameter.m_charSetForm;
				}
				else
				{
					short num = 3;
					if (parameter.m_bDuplicateBind)
					{
						num = 128;
					}
					if (parameter.CollectionType == OracleCollectionType.PLSQLAssociativeArray)
					{
						num = (short)(num | 0x40);
					}
					if (num != cachedParamMetadata.m_flag)
					{
						bMetadataModified = true;
						cachedParamMetadata.m_flag = num;
					}
					int num2 = 0;
					if (parameter.CollectionType == OracleCollectionType.PLSQLAssociativeArray)
					{
						num2 = parameter.m_maxNoOfArrayElements;
					}
					if (num2 != cachedParamMetadata.m_maxNoOfArrayElements)
					{
						bMetadataModified = true;
						cachedParamMetadata.m_maxNoOfArrayElements = num2;
					}
					if ((short)parameter.m_oraType != cachedParamMetadata.m_dataType)
					{
						bMetadataModified = true;
						cachedParamMetadata.m_dataType = (short)parameter.m_oraType;
					}
					if (parameter.Precision != cachedParamMetadata.m_precision)
					{
						bMetadataModified = true;
						cachedParamMetadata.m_precision = 0;
					}
					if (parameter.Scale != cachedParamMetadata.m_scale)
					{
						bMetadataModified = true;
						cachedParamMetadata.m_scale = 0;
					}
					int num3 = 0;
					if (parameter.m_oraType == OraType.ORA_CHAR || parameter.m_oraType == OraType.ORA_CHARN || parameter.m_oraType == OraType.ORA_VARCHAR)
					{
						num3 = 16;
					}
					if (cachedParamMetadata.m_contFlag != num3)
					{
						bMetadataModified = true;
						cachedParamMetadata.m_contFlag = num3;
					}
					if (cachedParamMetadata.m_maxLength != parameter.m_maxBytesToBeWrittenOrRead)
					{
						bMetadataModified = true;
						cachedParamMetadata.m_maxLength = parameter.m_maxBytesToBeWrittenOrRead;
					}
					if (parameter.m_oraType != OraType.ORA_INTY)
					{
						cachedParamMetadata.m_toid = null;
						cachedParamMetadata.m_version = 0;
					}
					else
					{
						cachedParamMetadata.m_toid = TTCXmlTypePickler.TOID;
						cachedParamMetadata.m_version = 1;
						cachedParamMetadata.m_characterSetId = 2;
					}
					if (cachedParamMetadata.m_characterSetForm != parameter.m_charSetForm)
					{
						bMetadataModified = true;
						cachedParamMetadata.m_characterSetForm = parameter.m_charSetForm;
					}
					if (cachedParamMetadata.m_characterSetId != parameter.m_characterSetId)
					{
						bMetadataModified = true;
						cachedParamMetadata.m_characterSetId = parameter.m_characterSetId;
					}
					columnDescribeInfo = cachedParamMetadata;
				}
				return columnDescribeInfo;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetParameterMetaData, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetParameterMetaData);
				}
			}
		}

		internal int SetCharDataArrayInBytes(OracleConnectionImpl connImpl, object paramValue, int[] bindSize, int offset, int noOfElems, bool[] nullIndicatorsForArrayBind, byte charSetForm)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetCharDataArrayInBytes);
			}
			try
			{
				int num = 0;
				int num2 = 0;
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						object value = ((Array)paramValue).GetValue(i);
						num2 = SetCharDataInBytes(connImpl, value, bindSize[i], offset, out m_paramValForArrayBindInBytes[i], charSetForm);
						if (num < num2)
						{
							num = num2;
						}
					}
				}
				return num;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetCharDataArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetCharDataArrayInBytes);
				}
			}
		}

		internal void SetRawDataArrayInBytes(object paramValue, int[] bindSize, int offset, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRawDataArrayInBytes);
			}
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						object value = ((Array)paramValue).GetValue(i);
						SetRawDataInBytes(value, bindSize[i], offset, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRawDataArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRawDataArrayInBytes);
				}
			}
		}

		internal int SetCharDataInBytes(OracleConnectionImpl connImpl, object paramValue, int size, int offset, byte charSetForm)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetCharDataInBytes);
			}
			try
			{
				return SetCharDataInBytes(connImpl, paramValue, size, offset, out m_paramValInBytes, charSetForm);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetCharDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetCharDataInBytes);
				}
			}
		}

		internal int SetCharDataInBytes(OracleConnectionImpl connImpl, object paramValue, int size, int offset, out byte[] charByteArray, byte charSetForm)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetCharDataInBytes);
			}
			try
			{
				char[] chars;
				string str;
				if ((str = paramValue as string) != null)
				{
					if (charSetForm != 2)
					{
						charByteArray = connImpl.m_marshallingEngine.m_dbCharSetConv.ConvertStringToBytes(str, offset, size);
					}
					else
					{
						charByteArray = connImpl.m_marshallingEngine.m_nCharSetConv.ConvertStringToBytes(str, offset, size);
					}
				}
				else if ((chars = paramValue as char[]) != null)
				{
					if (charSetForm != 2)
					{
						charByteArray = connImpl.m_marshallingEngine.m_dbCharSetConv.ConvertCharsToBytes(chars, offset, size);
					}
					else
					{
						charByteArray = connImpl.m_marshallingEngine.m_nCharSetConv.ConvertCharsToBytes(chars, offset, size);
					}
				}
				else if (paramValue is OracleString)
				{
					str = ((OracleString)paramValue).Value;
					if (charSetForm != 2)
					{
						charByteArray = connImpl.m_marshallingEngine.m_dbCharSetConv.ConvertStringToBytes(str, offset, size);
					}
					else
					{
						charByteArray = connImpl.m_marshallingEngine.m_nCharSetConv.ConvertStringToBytes(str, offset, size);
					}
				}
				else if (paramValue is char)
				{
					char[] array = new char[1]
					{
						(char)paramValue
					};
					if (charSetForm != 2)
					{
						charByteArray = connImpl.m_marshallingEngine.m_dbCharSetConv.ConvertCharsToBytes(array, 0, array.Length);
					}
					else
					{
						charByteArray = connImpl.m_marshallingEngine.m_nCharSetConv.ConvertCharsToBytes(array, 0, array.Length);
					}
				}
				else
				{
					str = Convert.ToString(paramValue);
					if (charSetForm != 2)
					{
						charByteArray = connImpl.m_marshallingEngine.m_dbCharSetConv.ConvertStringToBytes(str, 0, size);
					}
					else
					{
						charByteArray = connImpl.m_marshallingEngine.m_nCharSetConv.ConvertStringToBytes(str, 0, size);
					}
				}
				return charByteArray.Length;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetCharDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetCharDataInBytes);
				}
			}
		}

		internal bool IsJsonDataNullValue(object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.IsJsonDataNullValue);
			}
			try
			{
				string value = string.Empty;
				if (paramValue is string)
				{
					value = (string)paramValue;
				}
				else if (paramValue is OracleString && !((OracleString)paramValue).IsNull)
				{
					value = ((OracleString)paramValue).Value;
				}
				return string.IsNullOrEmpty(value);
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.IsJsonDataNullValue);
				}
			}
		}

		internal int SetJsonDataInBytes(OracleConnectionImpl connImpl, object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetJsonDataInBytes);
			}
			try
			{
				return SetJsonDataInBytes(connImpl, paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetJsonDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetJsonDataInBytes);
				}
			}
		}

		internal int SetJsonDataInBytes(OracleConnectionImpl connImpl, object paramValue, out byte[] oson)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetJsonDataInBytes);
			}
			string text = string.Empty;
			oson = new byte[0];
			try
			{
				if (paramValue is string)
				{
					text = (string)paramValue;
				}
				else if (paramValue is OracleString)
				{
					text = ((OracleString)paramValue).Value;
				}
				if (!string.IsNullOrEmpty(text))
				{
					oson = OracleJsonImpl.Encode(text);
					return oson.Length;
				}
				return 0;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetJsonDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetJsonDataInBytes);
				}
			}
		}

		internal int SetJsonArrayInBytes(OracleConnectionImpl connImpl, object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetJsonArrayInBytes);
			}
			try
			{
				int result = 0;
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						object value = ((Array)paramValue).GetValue(i);
						nullIndicatorsForArrayBind[i] = IsJsonDataNullValue(value);
						if (!nullIndicatorsForArrayBind[i])
						{
							result = SetJsonDataInBytes(connImpl, value, out m_paramValForArrayBindInBytes[i]);
						}
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetJsonArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetJsonArrayInBytes);
				}
			}
		}

		internal void SetInt32DataInBytes(object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt32DataInBytes);
			}
			try
			{
				SetInt32DataInBytes(paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt32DataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt32DataInBytes);
				}
			}
		}

		internal void SetInt32DataInBytes(object paramValue, out byte[] int32ByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt32DataInBytes);
			}
			byte[] array = null;
			try
			{
				if (paramValue is int)
				{
					int32ByteArray = OracleNumberCore.lnxmin(Convert.ToInt64((int)paramValue));
					return;
				}
				if (paramValue is OracleDecimal)
				{
					int32ByteArray = ((OracleDecimal)paramValue).InternalByteRepresentation;
					return;
				}
				if (paramValue is OracleString)
				{
					int32ByteArray = OracleNumberCore.lnxmin(Convert.ToInt64(((OracleString)paramValue).Value));
					return;
				}
				if ((array = paramValue as byte[]) != null)
				{
					int32ByteArray = array;
					return;
				}
				long longNum = Convert.ToInt64(paramValue);
				int32ByteArray = OracleNumberCore.lnxmin(longNum);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt32DataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt32DataInBytes);
				}
			}
		}

		internal void SetPlsqlBooleanDataInBytes(object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetPlsqlBooleanDataInBytes);
			}
			try
			{
				SetPlsqlBooleanDataInBytes(paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetPlsqlBooleanDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetPlsqlBooleanDataInBytes);
				}
			}
		}

		internal void SetPlsqlBooleanDataInBytes(object paramValue, out byte[] byteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetPlsqlBooleanDataInBytes);
			}
			bool flag = false;
			try
			{
				if ((paramValue is bool) ? ((bool)paramValue) : ((!(paramValue is OracleBoolean)) ? Convert.ToBoolean(paramValue) : ((OracleBoolean)paramValue).Value))
				{
					byteArray = TTCPLSQLBooleanAccessor.TRUE_VAL_BYTES;
				}
				else
				{
					byteArray = TTCPLSQLBooleanAccessor.FALSE_VAL_BYTES;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetPlsqlBooleanDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetPlsqlBooleanDataInBytes);
				}
			}
		}

		internal void SetInt64DataInBytes(object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt64DataInBytes);
			}
			try
			{
				SetInt64DataInBytes(paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt64DataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt64DataInBytes);
				}
			}
		}

		internal void SetInt64DataInBytes(object paramValue, out byte[] int64ByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt64DataInBytes);
			}
			byte[] array = null;
			try
			{
				if (paramValue is long)
				{
					int64ByteArray = OracleNumberCore.lnxmin((long)paramValue);
					return;
				}
				if (paramValue is OracleDecimal)
				{
					int64ByteArray = ((OracleDecimal)paramValue).InternalByteRepresentation;
					return;
				}
				if (paramValue is OracleString)
				{
					int64ByteArray = OracleNumberCore.lnxmin(Convert.ToInt64(((OracleString)paramValue).Value));
					return;
				}
				if ((array = paramValue as byte[]) != null)
				{
					int64ByteArray = array;
					return;
				}
				long longNum = Convert.ToInt64(paramValue);
				int64ByteArray = OracleNumberCore.lnxmin(longNum);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt64DataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt64DataInBytes);
				}
			}
		}

		internal void SetInt32ArrayInBytes(object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt32ArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetInt32DataInBytes(obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt32ArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt32ArrayInBytes);
				}
			}
		}

		internal void SetInt64ArrayInBytes(object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt64ArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetInt64DataInBytes(obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt64ArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetInt64ArrayInBytes);
				}
			}
		}

		internal void SetBinaryDoubleArrayInBytes(object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryDoubleArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetBinaryDoubleInBytes(obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryDoubleArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryDoubleArrayInBytes);
				}
			}
		}

		internal void SetClobArrayDataInBytes(OracleConnectionImpl connImpl, bool bIsNClob, object paramValue, int offset, int maxSize, int[] maxArrayBindSize, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetClobArrayDataInBytes);
			}
			object obj = null;
			try
			{
				m_saveValue = new object[noOfElems];
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetClobDataInBytes(connImpl, bIsNClob, obj, i, offset, maxSize, maxArrayBindSize, out m_paramValForArrayBindInBytes[i], out m_qLocatorDataForArrayBind[i], out m_saveValue[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetClobArrayDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetClobArrayDataInBytes);
				}
			}
		}

		internal void SetBlobArrayDataInBytes(OracleConnectionImpl connImpl, object paramValue, int offSet, int maxSize, int[] maxArrayBindSize, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBlobArrayDataInBytes);
			}
			object obj = null;
			try
			{
				m_saveValue = new object[noOfElems];
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetBlobDataInBytes(connImpl, obj, i, offSet, maxSize, maxArrayBindSize, out m_paramValForArrayBindInBytes[i], out m_qLocatorDataForArrayBind[i], out m_saveValue[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBlobArrayDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBlobArrayDataInBytes);
				}
			}
		}

		internal void SetBFileArrayInBytes(OracleConnectionImpl connImpl, object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBFileArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetBFileDataInBytes(connImpl, obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBFileArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBFileArrayInBytes);
				}
			}
		}

		internal void SetTimeStampArrayInBytes(object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetTimeStampInBytes(obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampArrayInBytes);
				}
			}
		}

		internal void SetTimeStampLTZArrayInBytes(OracleConnectionImpl connImpl, object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampLTZArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetTimeStampLTZInBytes(connImpl, obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampLTZArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampLTZArrayInBytes);
				}
			}
		}

		internal void SetTimeStampTZArrayInBytes(OracleConnectionImpl connImpl, object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampTZArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetTimeStampTZInBytes(connImpl, obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampTZArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampTZArrayInBytes);
				}
			}
		}

		internal void SetIntervalYMArrayInBytes(object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalYMArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetIntervalYMInBytes(obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalYMArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalYMArrayInBytes);
				}
			}
		}

		internal void SetIntervalDSArrayInBytes(object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalDSArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetIntervalDSInBytes(obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalDSArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalDSArrayInBytes);
				}
			}
		}

		internal void SetBinaryFloatArrayInBytes(object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryFloatArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetBinaryFloatInBytes(obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryFloatArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryFloatArrayInBytes);
				}
			}
		}

		internal void SetDecimalArrayInBytes(object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDecimalArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetDecimalDataInBytes(obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDecimalArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDecimalArrayInBytes);
				}
			}
		}

		internal void SetDateArrayInBytes(object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDateArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetDateInBytes(obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDateArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDateArrayInBytes);
				}
			}
		}

		internal void SetPlsqlBooleanArrayInBytes(object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetPlsqlBooleanArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetPlsqlBooleanDataInBytes(obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetPlsqlBooleanArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetPlsqlBooleanArrayInBytes);
				}
			}
		}

		internal void SetRefCursorArrayInBytes(OracleConnectionImpl connImpl, object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRefCursorArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetRefCursorDataInBytes(connImpl, obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRefCursorArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRefCursorArrayInBytes);
				}
			}
		}

		internal void SetDecimalDataInBytes(object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDecimalDataInBytes);
			}
			try
			{
				SetDecimalDataInBytes(paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDecimalDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDecimalDataInBytes);
				}
			}
		}

		internal void SetDecimalDataInBytes(object paramValue, out byte[] decimalByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDecimalDataInBytes);
			}
			byte[] array = null;
			try
			{
				OracleDecimal value;
				if (paramValue is decimal)
				{
					value = new OracleDecimal((decimal)paramValue);
				}
				else if (paramValue is byte)
				{
					value = new OracleDecimal((byte)paramValue);
				}
				else if (paramValue is short)
				{
					value = new OracleDecimal((short)paramValue);
				}
				else if (paramValue is int)
				{
					value = new OracleDecimal((int)paramValue);
				}
				else if (paramValue is long)
				{
					value = new OracleDecimal((long)paramValue);
				}
				else if (paramValue is float)
				{
					value = new OracleDecimal((float)paramValue);
					value = OracleDecimal.SetPrecisionNoRound(value, 7);
				}
				else if (paramValue is double)
				{
					value = new OracleDecimal((double)paramValue);
				}
				else if (paramValue is OracleDecimal)
				{
					value = (OracleDecimal)paramValue;
				}
				else if (paramValue is OracleString)
				{
					string value2 = ((OracleString)paramValue).Value;
					value = new OracleDecimal(value2);
				}
				else if (paramValue is string || paramValue is char || paramValue is char[])
				{
					string preBindBuffer_Str = GetPreBindBuffer_Str(paramValue);
					value = new OracleDecimal(preBindBuffer_Str);
				}
				else if ((array = paramValue as byte[]) == null)
				{
					value = ((!(paramValue is bool)) ? new OracleDecimal(Convert.ToDecimal(paramValue)) : new OracleDecimal((short)(((bool)paramValue) ? 1 : 0)));
				}
				else
				{
					if (array.Length != 22)
					{
						throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
					}
					value = new OracleDecimal(array);
				}
				if (m_precision != 100 || m_scale != 129)
				{
					OracleDecimal oracleDecimal = OracleDecimal.Null;
					if (m_precision != 100 && m_scale != 129)
					{
						oracleDecimal = OracleDecimal.ConvertToPrecScale(value, m_precision, m_scale);
					}
					else if (m_precision != 100)
					{
						oracleDecimal = OracleDecimal.SetPrecision(value, m_precision);
					}
					else if (m_scale != 129)
					{
						oracleDecimal = OracleDecimal.AdjustScale(value, m_scale, fRound: true);
					}
					decimalByteArray = oracleDecimal.InternalByteRepresentation;
				}
				else
				{
					decimalByteArray = value.InternalByteRepresentation;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDecimalDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDecimalDataInBytes);
				}
			}
		}

		internal void SetBinaryDoubleInBytes(object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryDoubleInBytes);
			}
			try
			{
				SetBinaryDoubleInBytes(paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryDoubleInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryDoubleInBytes);
				}
			}
		}

		internal void SetBinaryDoubleInBytes(object paramValue, out byte[] bdoubleByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryDoubleInBytes);
			}
			byte[] array = null;
			try
			{
				if (paramValue is double)
				{
					bdoubleByteArray = TTCBinaryDoubleAccessor.DoubleToCanonicalFormatBytes((double)paramValue);
				}
				else if (paramValue is OracleDecimal)
				{
					bdoubleByteArray = TTCBinaryDoubleAccessor.DoubleToCanonicalFormatBytes(((OracleDecimal)paramValue).ToDouble());
				}
				else if ((array = paramValue as byte[]) != null)
				{
					if (array.Length != TTCBinaryDoubleAccessor.BINARY_DOUBLE_MAX_LENGTH)
					{
						throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
					}
					bdoubleByteArray = array;
				}
				else if (paramValue is string || paramValue is char[] || paramValue is OracleString || paramValue is char)
				{
					string preBindBuffer_Str = GetPreBindBuffer_Str(paramValue);
					bdoubleByteArray = TTCBinaryDoubleAccessor.DoubleToCanonicalFormatBytes(new OracleDecimal(preBindBuffer_Str).ToDouble());
				}
				else
				{
					double d = Convert.ToDouble(paramValue);
					bdoubleByteArray = TTCBinaryDoubleAccessor.DoubleToCanonicalFormatBytes(d);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryDoubleInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryDoubleInBytes);
				}
			}
		}

		internal void SetDoubleInBytes(object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDoubleInBytes);
			}
			try
			{
				SetDoubleInBytes(paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDoubleInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDoubleInBytes);
				}
			}
		}

		internal void SetDoubleInBytes(object paramValue, out byte[] doubleByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDoubleInBytes);
			}
			byte[] array = null;
			try
			{
				double doubleNum;
				if (paramValue is double)
				{
					doubleNum = (double)paramValue;
				}
				else if (paramValue is OracleDecimal)
				{
					doubleNum = ((OracleDecimal)paramValue).ToDouble();
				}
				else if (paramValue is string || paramValue is char[] || paramValue is OracleString || paramValue is char)
				{
					doubleNum = new OracleDecimal(GetPreBindBuffer_Str(paramValue)).ToDouble();
				}
				else if ((array = paramValue as byte[]) != null)
				{
					if (array.Length != 22)
					{
						throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND));
					}
					doubleNum = new OracleDecimal(array).ToDouble();
				}
				else
				{
					doubleNum = Convert.ToDouble(paramValue);
				}
				doubleByteArray = OracleNumberCore.GetByteRep(doubleNum);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDoubleInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDoubleInBytes);
				}
			}
		}

		internal void SetDoubleArrayInBytes(object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDoubleArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetDoubleInBytes(obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDoubleArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDoubleArrayInBytes);
				}
			}
		}

		internal void SetSingleInBytes(object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetSingleInBytes);
			}
			try
			{
				SetSingleInBytes(paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetSingleInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetSingleInBytes);
				}
			}
		}

		internal void SetSingleInBytes(object paramValue, out byte[] singeByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetSingleInBytes);
			}
			byte[] array = null;
			try
			{
				OracleDecimal value;
				if (paramValue is float)
				{
					value = new OracleDecimal((double)(float)paramValue);
				}
				else if (paramValue is OracleDecimal)
				{
					value = (OracleDecimal)paramValue;
				}
				else if (!(paramValue is string) && !(paramValue is char[]) && !(paramValue is OracleString) && !(paramValue is char))
				{
					value = (((array = paramValue as byte[]) == null) ? new OracleDecimal((double)Convert.ToSingle(paramValue)) : new OracleDecimal(array));
				}
				else
				{
					string preBindBuffer_Str = GetPreBindBuffer_Str(paramValue);
					value = new OracleDecimal(preBindBuffer_Str);
				}
				singeByteArray = OracleDecimal.SetPrecisionNoRound(value, 7).InternalByteRepresentation;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetSingleInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetSingleInBytes);
				}
			}
		}

		internal void SetSingleArrayInBytes(object paramValue, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetSingleArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetSingleInBytes(obj, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetSingleArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetSingleArrayInBytes);
				}
			}
		}

		internal void SetBinaryFloatInBytes(object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryFloatInBytes);
			}
			try
			{
				SetBinaryFloatInBytes(paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryFloatInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryFloatInBytes);
				}
			}
		}

		internal void SetBinaryFloatInBytes(object paramValue, out byte[] bfloatByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryFloatInBytes);
			}
			byte[] array = null;
			try
			{
				if (paramValue is float)
				{
					bfloatByteArray = TTCBinaryFloatAccessor.FloatToCanonicalFormatBytes((float)paramValue);
				}
				else if (paramValue is OracleDecimal)
				{
					bfloatByteArray = TTCBinaryFloatAccessor.FloatToCanonicalFormatBytes(((OracleDecimal)paramValue).ToSingle());
				}
				else if (paramValue is string || paramValue is char[] || paramValue is OracleString || paramValue is char)
				{
					string preBindBuffer_Str = GetPreBindBuffer_Str(paramValue);
					bfloatByteArray = TTCBinaryFloatAccessor.FloatToCanonicalFormatBytes(new OracleDecimal(preBindBuffer_Str).ToSingle());
				}
				else if ((array = paramValue as byte[]) != null)
				{
					if (array.Length != TTCBinaryFloatAccessor.BINARY_FLOAT_MAX_LENGTH)
					{
						throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
					}
					bfloatByteArray = array;
				}
				else
				{
					float f = Convert.ToSingle(paramValue);
					bfloatByteArray = TTCBinaryFloatAccessor.FloatToCanonicalFormatBytes(f);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryFloatInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBinaryFloatInBytes);
				}
			}
		}

		internal void SetTimeStampInBytes(object bindValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampInBytes);
			}
			try
			{
				SetTimeStampInBytes(bindValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampInBytes);
				}
			}
		}

		internal void SetTimeStampInBytes(object bindValue, out byte[] timeStampByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampInBytes);
			}
			byte[] array = null;
			try
			{
				if ((array = bindValue as byte[]) != null)
				{
					if (array.Length != 11)
					{
						throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
					}
				}
				else
				{
					OracleTimeStamp oracleTimeStamp;
					if (bindValue is DateTime)
					{
						oracleTimeStamp = new OracleTimeStamp((DateTime)bindValue);
					}
					else if (bindValue is OracleTimeStamp)
					{
						oracleTimeStamp = (OracleTimeStamp)bindValue;
					}
					else if (bindValue is OracleTimeStampLTZ)
					{
						oracleTimeStamp = ((OracleTimeStampLTZ)bindValue).ToOracleTimeStamp();
					}
					else if (bindValue is OracleTimeStampTZ)
					{
						oracleTimeStamp = ((OracleTimeStampTZ)bindValue).ToOracleTimeStamp();
					}
					else if (bindValue is OracleDate)
					{
						oracleTimeStamp = (OracleDate)bindValue;
					}
					else
					{
						if (!(bindValue is string) && !(bindValue is char[]) && !(bindValue is OracleString) && !(bindValue is char))
						{
							throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
						}
						string preBindBuffer_Str = GetPreBindBuffer_Str(bindValue);
						oracleTimeStamp = new OracleTimeStamp(preBindBuffer_Str);
					}
					array = oracleTimeStamp.InternalByteRepresentation;
				}
				bool flag = false;
				for (int i = 7; i < array.Length; i++)
				{
					if (array[i] != 0)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					timeStampByteArray = new byte[7];
					Array.Copy(array, timeStampByteArray, 7);
				}
				else
				{
					timeStampByteArray = array;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampInBytes);
				}
			}
		}

		internal void SetTimeStampLTZInBytes(OracleConnectionImpl connImpl, object bindValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampLTZInBytes);
			}
			try
			{
				SetTimeStampLTZInBytes(connImpl, bindValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampLTZInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampLTZInBytes);
				}
			}
		}

		internal void SetTimeStampLTZInBytes(OracleConnectionImpl connImpl, object bindValue, out byte[] timeStampTZByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampLTZInBytes);
			}
			byte[] array = null;
			try
			{
				if ((array = bindValue as byte[]) != null)
				{
					if (array.Length != 11)
					{
						throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
					}
				}
				else
				{
					OracleTimeStampLTZ oracleTimeStampLTZ;
					if (bindValue is DateTime)
					{
						oracleTimeStampLTZ = new OracleTimeStampLTZ((DateTime)bindValue);
					}
					else if (bindValue is OracleTimeStamp)
					{
						oracleTimeStampLTZ = ((OracleTimeStamp)bindValue).ToOracleTimeStampLTZ();
					}
					else if (bindValue is OracleTimeStampLTZ)
					{
						oracleTimeStampLTZ = (OracleTimeStampLTZ)bindValue;
					}
					else if (bindValue is OracleTimeStampTZ)
					{
						oracleTimeStampLTZ = ((OracleTimeStampTZ)bindValue).ToOracleTimeStampLTZ();
					}
					else if (bindValue is OracleDate)
					{
						oracleTimeStampLTZ = (OracleDate)bindValue;
					}
					else
					{
						if (!(bindValue is string) && !(bindValue is char[]) && !(bindValue is OracleString) && !(bindValue is char))
						{
							throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
						}
						string preBindBuffer_Str = GetPreBindBuffer_Str(bindValue);
						oracleTimeStampLTZ = new OracleTimeStampLTZ(preBindBuffer_Str);
					}
					array = TimeStamp.ConvertLTZDataToDBTime(oracleTimeStampLTZ.InternalByteRepresentation, connImpl.GetDBTimeZoneBytes(), connImpl.m_sessionTimeZone);
				}
				bool flag = false;
				for (int i = 7; i < array.Length; i++)
				{
					if (array[i] != 0)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					timeStampTZByteArray = new byte[7];
					Array.Copy(array, timeStampTZByteArray, 7);
				}
				else
				{
					timeStampTZByteArray = array;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampLTZInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampLTZInBytes);
				}
			}
		}

		internal void SetTimeStampTZInBytes(OracleConnectionImpl connImpl, object bindValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampTZInBytes);
			}
			try
			{
				SetTimeStampTZInBytes(connImpl, bindValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampTZInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampTZInBytes);
				}
			}
		}

		internal void SetTimeStampTZInBytes(OracleConnectionImpl connImpl, object bindValue, out byte[] timeStampLTZByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampTZInBytes);
			}
			byte[] array = null;
			try
			{
				if ((array = bindValue as byte[]) != null)
				{
					if (array.Length != 13)
					{
						throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
					}
				}
				else
				{
					OracleTimeStampTZ oracleTimeStampTZ;
					if (bindValue is DateTime)
					{
						oracleTimeStampTZ = new OracleTimeStampTZ((DateTime)bindValue);
					}
					else if (bindValue is OracleTimeStamp)
					{
						oracleTimeStampTZ = ((OracleTimeStamp)bindValue).ToOracleTimeStampTZ();
					}
					else if (bindValue is OracleTimeStampLTZ)
					{
						oracleTimeStampTZ = ((OracleTimeStampLTZ)bindValue).ToOracleTimeStampTZ();
					}
					else if (bindValue is OracleTimeStampTZ)
					{
						oracleTimeStampTZ = (OracleTimeStampTZ)bindValue;
					}
					else if (bindValue is OracleDate)
					{
						oracleTimeStampTZ = (OracleDate)bindValue;
					}
					else if (bindValue is string || bindValue is char[] || bindValue is OracleString || bindValue is char)
					{
						string preBindBuffer_Str = GetPreBindBuffer_Str(bindValue);
						oracleTimeStampTZ = new OracleTimeStampTZ(preBindBuffer_Str);
					}
					else
					{
						if (!(bindValue is DateTimeOffset))
						{
							throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
						}
						oracleTimeStampTZ = new OracleTimeStampTZ(((DateTimeOffset)bindValue).DateTime, ((DateTimeOffset)bindValue).Offset.ToString());
					}
					array = oracleTimeStampTZ.InternalByteRepresentation;
					if (!m_bSkipConversionToLocalTime && connImpl.IsTZDataSentAsLocalTime)
					{
						array = TimeStamp.GetLocalTimeFromUTCByteRep(array);
					}
				}
				bool flag = false;
				for (int i = 7; i < array.Length; i++)
				{
					if (array[i] != 0)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					timeStampLTZByteArray = new byte[7];
					Array.Copy(array, timeStampLTZByteArray, 7);
				}
				else
				{
					timeStampLTZByteArray = array;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampTZInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetTimeStampTZInBytes);
				}
			}
		}

		internal void SetIntervalDSInBytes(object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalDSInBytes);
			}
			try
			{
				SetIntervalDSInBytes(paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalDSInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalDSInBytes);
				}
			}
		}

		internal void SetIntervalDSInBytes(object paramValue, out byte[] intervalDSByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalDSInBytes);
			}
			byte[] array = null;
			try
			{
				if ((array = paramValue as byte[]) != null)
				{
					intervalDSByteArray = array;
					return;
				}
				OracleIntervalDS oracleIntervalDS;
				if (paramValue is OracleIntervalDS)
				{
					oracleIntervalDS = (OracleIntervalDS)paramValue;
				}
				else if (paramValue is TimeSpan)
				{
					oracleIntervalDS = new OracleIntervalDS((TimeSpan)paramValue);
				}
				else if (paramValue is string || paramValue is char[] || paramValue is OracleString || paramValue is char)
				{
					oracleIntervalDS = new OracleIntervalDS(GetPreBindBuffer_Str(paramValue));
				}
				else
				{
					if (!(paramValue is decimal))
					{
						throw new ArgumentException();
					}
					oracleIntervalDS = new OracleIntervalDS(TimeSpan.FromSeconds((double)(decimal)paramValue));
				}
				intervalDSByteArray = oracleIntervalDS.InternalByteRepresentation;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalDSInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalDSInBytes);
				}
			}
		}

		internal void SetIntervalYMInBytes(object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalYMInBytes);
			}
			try
			{
				SetIntervalYMInBytes(paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalYMInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalYMInBytes);
				}
			}
		}

		internal void SetIntervalYMInBytes(object paramValue, out byte[] intervalYMByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalYMInBytes);
			}
			byte[] array = null;
			try
			{
				if ((array = paramValue as byte[]) != null)
				{
					intervalYMByteArray = array;
					return;
				}
				OracleIntervalYM oracleIntervalYM;
				if (paramValue is OracleIntervalYM)
				{
					oracleIntervalYM = (OracleIntervalYM)paramValue;
				}
				else if (paramValue is byte || paramValue is short || paramValue is int || paramValue is long)
				{
					oracleIntervalYM = new OracleIntervalYM((long)paramValue);
				}
				else if (paramValue is string || paramValue is char[] || paramValue is OracleString || paramValue is char)
				{
					oracleIntervalYM = new OracleIntervalYM(GetPreBindBuffer_Str(paramValue));
				}
				else
				{
					if (!(paramValue is decimal))
					{
						throw new ArgumentException();
					}
					oracleIntervalYM = new OracleIntervalYM((long)(decimal)paramValue);
				}
				intervalYMByteArray = oracleIntervalYM.InternalByteRepresentation;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalYMInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetIntervalYMInBytes);
				}
			}
		}

		internal void SetRawDataInBytes(object paramValue, int size, int offSet)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRawDataInBytes);
			}
			try
			{
				SetRawDataInBytes(paramValue, size, offSet, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRawDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRawDataInBytes);
				}
			}
		}

		internal void SetRawDataInBytes(object paramValue, int size, int offSet, out byte[] rawByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRawDataInBytes);
			}
			byte[] array = null;
			rawByteArray = null;
			try
			{
				if ((array = paramValue as byte[]) != null)
				{
					if (offSet > 0 || size != array.Length)
					{
						rawByteArray = new byte[size];
						Array.Copy(array, offSet, rawByteArray, 0, size);
					}
					else
					{
						rawByteArray = array;
					}
				}
				else if (paramValue is OracleBinary)
				{
					array = ((OracleBinary)paramValue).m_value;
					if (offSet > 0 || size != array.Length)
					{
						rawByteArray = new byte[size];
						Array.Copy(array, offSet, rawByteArray, 0, size);
					}
					else
					{
						rawByteArray = array;
					}
				}
				else if (paramValue is Guid)
				{
					array = ((Guid)paramValue).ToByteArray();
					if (offSet > 0 || size != array.Length)
					{
						rawByteArray = new byte[size];
						Array.Copy(array, offSet, rawByteArray, 0, size);
					}
					else
					{
						rawByteArray = array;
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRawDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRawDataInBytes);
				}
			}
		}

		internal void SetDateInBytes(object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDateInBytes);
			}
			try
			{
				SetDateInBytes(paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDateInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDateInBytes);
				}
			}
		}

		internal void SetDateInBytes(object paramValue, out byte[] dateByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDateInBytes);
			}
			dateByteArray = null;
			try
			{
				byte[] array;
				if (paramValue is DateTime)
				{
					dateByteArray = new byte[7];
					TTCDateTimeAccessor.GetOracleDate(dateByteArray, (DateTime)paramValue);
				}
				else if (paramValue is OracleDate)
				{
					dateByteArray = ((OracleDate)paramValue).InternalByteRepresentation;
				}
				else if (paramValue is OracleTimeStamp)
				{
					dateByteArray = new byte[7];
					Array.Copy(((OracleTimeStamp)paramValue).InternalByteRepresentation, dateByteArray, 7);
				}
				else if (paramValue is OracleTimeStampLTZ)
				{
					dateByteArray = new byte[7];
					Array.Copy(((OracleTimeStampLTZ)paramValue).InternalByteRepresentation, dateByteArray, 7);
				}
				else if (paramValue is OracleTimeStampTZ)
				{
					dateByteArray = ((OracleTimeStampTZ)paramValue).ToOracleDate().InternalByteRepresentation;
				}
				else if (paramValue is string || paramValue is char[] || paramValue is OracleString || paramValue is char)
				{
					string preBindBuffer_Str = GetPreBindBuffer_Str(paramValue);
					dateByteArray = new OracleDate(preBindBuffer_Str).InternalByteRepresentation;
				}
				else if ((array = paramValue as byte[]) != null)
				{
					int year = (array[0] - 100) * 100 + array[1] - 100;
					int month = array[2];
					int day = array[3];
					int hour = array[4] - 1;
					int minute = array[5] - 1;
					int second = array[6] - 1;
					if (!TimeStamp.IsValidDateTime(year, month, day, hour, minute, second, 0))
					{
						throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
					}
					dateByteArray = array;
				}
				else
				{
					DateTime data = Convert.ToDateTime(paramValue);
					dateByteArray = new OracleDate(data).InternalByteRepresentation;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDateInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetDateInBytes);
				}
			}
		}

		internal void SetBlobDataInBytes(OracleConnectionImpl connImpl, object paramValue, int offSet, int maxSize, int[] maxArrayBindSize)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBlobDataInBytes);
			}
			try
			{
				m_saveValue = new object[1];
				SetBlobDataInBytes(connImpl, paramValue, 0, offSet, maxSize, maxArrayBindSize, out m_paramValInBytes, out m_qLocatorData, out m_saveValue[0]);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBlobDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBlobDataInBytes);
				}
			}
		}

		internal void SetBlobDataInBytes(OracleConnectionImpl connImpl, object paramValue, int index, int offSet, int maxSize, int[] maxArrayBindSize, out byte[] blobDataInBytes, out byte[] qLocatorData, out object saveValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBlobDataInBytes);
			}
			try
			{
				qLocatorData = null;
				saveValue = null;
				OracleBlob oracleBlob = paramValue as OracleBlob;
				if (oracleBlob != null)
				{
					if (oracleBlob.m_connection.m_oracleConnectionImpl != connImpl)
					{
						throw new InvalidOperationException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.CON_DIFFERENT_CONNECTIONS));
					}
					if (oracleBlob.m_blobImpl.m_isTemporaryLob && !oracleBlob.m_blobImpl.m_doneTempLobCreate)
					{
						oracleBlob.CreateTempLob();
					}
					blobDataInBytes = oracleBlob.GetLobLocator();
					if (TTCLob.IsQuasiLocator(blobDataInBytes))
					{
						qLocatorData = oracleBlob.m_blobImpl.m_lobPrefetchData;
					}
				}
				else
				{
					byte[] preBindBuffer_Raw = GetPreBindBuffer_Raw(paramValue, bArrayBind: false, 0);
					int bindingSize = GetBindingSize(preBindBuffer_Raw, maxArrayBindSize != null, index, offSet, maxSize, maxArrayBindSize);
					OracleBlobImpl oracleBlobImpl = new OracleBlobImpl(connImpl, null, bCaching: false);
					oracleBlobImpl.CreateTemporaryLob();
					saveValue = oracleBlobImpl;
					if (bindingSize > 0)
					{
						oracleBlobImpl.Write(1L, preBindBuffer_Raw, offSet, bindingSize);
					}
					blobDataInBytes = oracleBlobImpl.m_lobLocator;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBlobDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBlobDataInBytes);
				}
			}
		}

		internal void SetBFileDataInBytes(OracleConnectionImpl connectionImpl, object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBFileDataInBytes);
			}
			try
			{
				SetBFileDataInBytes(connectionImpl, paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBFileDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBFileDataInBytes);
				}
			}
		}

		internal void SetBFileDataInBytes(OracleConnectionImpl connectionImpl, object paramValue, out byte[] bfileByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBFileDataInBytes);
			}
			try
			{
				OracleBFile oracleBFile = paramValue as OracleBFile;
				if (oracleBFile != null)
				{
					if (oracleBFile.m_connection.m_oracleConnectionImpl != connectionImpl)
					{
						throw new InvalidOperationException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.CON_DIFFERENT_CONNECTIONS));
					}
					bfileByteArray = oracleBFile.GetLobLocator();
					return;
				}
				throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBFileDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetBFileDataInBytes);
				}
			}
		}

		internal void SetRefCursorDataInBytes(OracleConnectionImpl connImpl, object paramValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRefCursorDataInBytes);
			}
			try
			{
				SetRefCursorDataInBytes(connImpl, paramValue, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRefCursorDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRefCursorDataInBytes);
				}
			}
		}

		internal void SetRefCursorDataInBytes(OracleConnectionImpl connImpl, object paramValue, out byte[] refCursorByteArray)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRefCursorDataInBytes);
			}
			try
			{
				OracleRefCursor oracleRefCursor = paramValue as OracleRefCursor;
				if (oracleRefCursor != null && oracleRefCursor.Connection != null)
				{
					if (oracleRefCursor.Connection.m_oracleConnectionImpl == connImpl)
					{
						refCursorByteArray = BitConverter.GetBytes(oracleRefCursor.m_refCursorImpl.m_cursorId);
						return;
					}
					throw new InvalidOperationException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.CON_DIFFERENT_CONNECTIONS));
				}
				throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRefCursorDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetRefCursorDataInBytes);
				}
			}
		}

		internal void SetClobDataInBytes(OracleConnectionImpl connImpl, bool bIsNClob, object paramValue, int offset, int maxSize, int[] maxArrayBindSize)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetClobDataInBytes);
			}
			try
			{
				m_saveValue = new object[1];
				SetClobDataInBytes(connImpl, bIsNClob, paramValue, 0, offset, maxSize, maxArrayBindSize, out m_paramValInBytes, out m_qLocatorData, out m_saveValue[0]);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetClobDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetClobDataInBytes);
				}
			}
		}

		internal void SetClobDataInBytes(OracleConnectionImpl connImpl, bool bIsNClob, object paramValue, int index, int offset, int maxSize, int[] maxArrayBindSize, out byte[] clobByteArray, out byte[] qLocatorData, out object saveValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetClobDataInBytes);
			}
			try
			{
				qLocatorData = null;
				saveValue = null;
				OracleClob oracleClob = paramValue as OracleClob;
				if (oracleClob != null)
				{
					if (oracleClob.m_connection.m_oracleConnectionImpl != connImpl)
					{
						throw new InvalidOperationException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.CON_DIFFERENT_CONNECTIONS));
					}
					if (oracleClob.m_clobImpl.m_isTemporaryLob && !oracleClob.m_clobImpl.m_doneTempLobCreate)
					{
						oracleClob.CreateTempLob();
					}
					clobByteArray = oracleClob.GetLobLocator();
					if (TTCLob.IsQuasiLocator(clobByteArray))
					{
						qLocatorData = oracleClob.m_clobImpl.m_lobPrefetchData;
					}
				}
				else
				{
					char[] preBindBuffer_Char = GetPreBindBuffer_Char(paramValue, bArraybind: false, 0);
					int bindingSize = GetBindingSize(preBindBuffer_Char, maxArrayBindSize != null, index, offset, maxSize, maxArrayBindSize);
					OracleClobImpl oracleClobImpl = new OracleClobImpl(connImpl, null, bIsNClob, bCache: false);
					oracleClobImpl.CreateTemporaryLob();
					saveValue = oracleClobImpl;
					if (bindingSize > 0)
					{
						oracleClobImpl.Write(1L, bIsNClob, preBindBuffer_Char, offset, bindingSize);
					}
					clobByteArray = oracleClobImpl.m_lobLocator;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetClobDataInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetClobDataInBytes);
				}
			}
		}

		internal void SetXmlTypeInBytes(OracleConnectionImpl connImpl, object paramValue, int offset, int maxSize, int[] maxArrayBindSize)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetXmlTypeInBytes);
			}
			try
			{
				SetXmlTypeInBytes(connImpl, paramValue, offset, maxSize, maxArrayBindSize, out m_paramValInBytes);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetXmlTypeInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetXmlTypeInBytes);
				}
			}
		}

		internal void SetXmlTypeInBytes(OracleConnectionImpl connImpl, object paramValue, int offset, int maxSize, int[] maxArrayBindSize, out byte[] bytes)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetXmlTypeInBytes);
			}
			bytes = null;
			OracleXmlType oracleXmlType = null;
			OracleClob oracleClob = null;
			try
			{
				if ((oracleXmlType = paramValue as OracleXmlType) != null)
				{
					if (oracleXmlType.m_connection.m_oracleConnectionImpl != connImpl)
					{
						throw new InvalidOperationException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.CON_DIFFERENT_CONNECTIONS));
					}
					bytes = TTCXmlTypePickler.Pickle(connImpl.m_marshallingEngine.m_dbCharSetConv, oracleXmlType.m_xmlTypeImpl);
				}
				else if ((oracleClob = paramValue as OracleClob) != null)
				{
					if (oracleClob.m_connection.m_oracleConnectionImpl != connImpl)
					{
						throw new InvalidOperationException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.CON_DIFFERENT_CONNECTIONS));
					}
					bytes = TTCXmlTypePickler.Pickle(connImpl.m_marshallingEngine.m_dbCharSetConv, TypeOfXmlType.Clob, TypeOfXmlData.Clob, offset, maxSize, oracleClob);
				}
				else
				{
					char[] preBindBuffer_Char = GetPreBindBuffer_Char(paramValue, bArraybind: false, 0);
					int bindingSize = GetBindingSize(preBindBuffer_Char, bArrayBind: false, 0, offset, maxSize, maxArrayBindSize);
					bytes = TTCXmlTypePickler.Pickle(connImpl.m_marshallingEngine.m_dbCharSetConv, TypeOfXmlType.String, TypeOfXmlData.Chars, offset, bindingSize, preBindBuffer_Char);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetXmlTypeInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetXmlTypeInBytes);
				}
			}
		}

		internal void SetXmlTypeArrayInBytes(OracleConnectionImpl connImpl, object paramValue, int offset, int maxSize, int[] maxArrayBindSize, int noOfElems, bool[] nullIndicatorsForArrayBind)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetXmlTypeArrayInBytes);
			}
			object obj = null;
			try
			{
				for (int i = 0; i < noOfElems; i++)
				{
					if (!nullIndicatorsForArrayBind[i])
					{
						obj = ((Array)paramValue).GetValue(i);
						SetXmlTypeInBytes(connImpl, obj, offset, maxSize, maxArrayBindSize, out m_paramValForArrayBindInBytes[i]);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetXmlTypeArrayInBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.SetXmlTypeArrayInBytes);
				}
			}
		}

		private char[] GetPreBindBuffer_Char(object parameterValue, bool bArraybind, int index)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPreBindBuffer_Char);
			}
			char[] array = null;
			object obj = null;
			try
			{
				if (!bArraybind)
				{
					obj = parameterValue;
				}
				else
				{
					Array array2;
					if ((array2 = parameterValue as Array) == null)
					{
						throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
					}
					obj = array2.GetValue(index);
				}
				string text;
				if ((text = obj as string) != null)
				{
					return text.ToCharArray();
				}
				char[] result;
				if ((result = obj as char[]) != null)
				{
					return result;
				}
				if (obj is char)
				{
					return ((char)obj).ToString().ToCharArray();
				}
				if (obj is OracleString)
				{
					return ((OracleString)obj).Value.ToCharArray();
				}
				return Convert.ToString(obj)!.ToCharArray();
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPreBindBuffer_Char, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPreBindBuffer_Char);
				}
			}
		}

		private string GetPreBindBuffer_Str(object bindValue)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPreBindBuffer_Str);
			}
			try
			{
				string result;
				if ((result = bindValue as string) != null)
				{
					return result;
				}
				char[] value;
				if ((value = bindValue as char[]) != null)
				{
					return new string(value);
				}
				if (bindValue is char)
				{
					return new string((char)bindValue, 1);
				}
				if (bindValue is OracleString)
				{
					return ((OracleString)bindValue).Value;
				}
				return Convert.ToString(bindValue);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPreBindBuffer_Str, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPreBindBuffer_Str);
				}
			}
		}

		private int GetBindingSize(Array buffer, bool bArrayBind, int idx, int offset, int maxSize, int[] maxArrayBindSize)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBindingSize);
			}
			try
			{
				int num = ((!bArrayBind) ? ((maxSize != -1) ? maxSize : buffer.Length) : ((maxArrayBindSize[idx] != -1) ? maxArrayBindSize[idx] : buffer.Length));
				if (offset > buffer.Length)
				{
					throw new ArgumentException("Invalid offset", "Parameter Name");
				}
				if (offset + num > buffer.Length)
				{
					num = buffer.Length - offset;
				}
				return num;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBindingSize, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBindingSize);
				}
			}
		}

		private byte[] GetPreBindBuffer_Raw(object parameterValue, bool bArrayBind, int index)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPreBindBuffer_Raw);
			}
			object obj = null;
			try
			{
				if (!bArrayBind)
				{
					obj = parameterValue;
				}
				else
				{
					Array array;
					if ((array = parameterValue as Array) == null)
					{
						throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
					}
					obj = array.GetValue(index);
				}
				byte[] array2 = null;
				byte[] result;
				if ((result = obj as byte[]) != null)
				{
					return result;
				}
				if (obj is OracleBinary)
				{
					return ((OracleBinary)obj).Value;
				}
				throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND), "ParameterName");
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPreBindBuffer_Raw, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPreBindBuffer_Raw);
				}
			}
		}

		internal object GetCharDataFromBytes(Accessor accessor, PrmEnumType enumType, byte charSetForm, int maxSize, char[] charArrayFromPooler)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetCharDataFromBytes);
			}
			try
			{
				object obj = null;
				TTCVarcharAccessor tTCVarcharAccessor = accessor as TTCVarcharAccessor;
				if (tTCVarcharAccessor != null && !tTCVarcharAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractCharFromAccessor(accessor, enumType, charSetForm, maxSize, 0, charArrayFromPooler, out m_curSize);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleString.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetCharDataFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetCharDataFromBytes);
				}
			}
		}

		internal object GetRefCursorFromBytes(OracleConnection conn, Accessor accessor, long fetchSize, PrmEnumType enumType, OracleIntervalDS sessionTimeZone, string commandText, string paramPosOrName, long longFetchSize, long clientInitialLOBFS, long internalInitialLOBFS, long internalInitialJSONFS, long[] scnFromExecution, bool bCallFromExecuteReader)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRefCursorFromBytes);
			}
			try
			{
				TTCRefCursorAccessor tTCRefCursorAccessor = accessor as TTCRefCursorAccessor;
				object obj = null;
				if (tTCRefCursorAccessor != null && !tTCRefCursorAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractRefCursorFromAccessor(conn, tTCRefCursorAccessor, fetchSize, enumType, sessionTimeZone, commandText, paramPosOrName, longFetchSize, clientInitialLOBFS, internalInitialLOBFS, internalInitialJSONFS, scnFromExecution, 0, bCallFromExecuteReader);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? ((object)DBNull.Value) : ((object)OracleRefCursor.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRefCursorFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRefCursorFromBytes);
				}
			}
		}

		internal void GetLobDataFromBytes(OracleConnection conn, Accessor accessor, PrmEnumType enumType, OraType oraType, ref object value, bool isInputOutput, byte charSetForm)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLobDataFromBytes);
			}
			try
			{
				ExtractLobDataFromAccessor(conn, accessor, enumType, oraType, ref value, isInputOutput, charSetForm, ref m_curSize, ref m_status, 0);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLobDataFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLobDataFromBytes);
				}
			}
		}

		private void ExtractLobDataFromAccessor(OracleConnection conn, Accessor accessor, PrmEnumType enumType, OraType oraType, ref object value, bool isInputOutput, byte charSetForm, ref int curSize, ref OracleParameterStatus status, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractLobDataFromAccessor);
			}
			try
			{
				TTCLobAccessor tTCLobAccessor = accessor as TTCLobAccessor;
				byte[] array = null;
				if (tTCLobAccessor != null && !tTCLobAccessor.IsNullIndicatorSet(currentRow))
				{
					array = tTCLobAccessor.GetLobLocator(currentRow);
				}
				if (array == null)
				{
					if (isInputOutput && value != null)
					{
						if (value is OracleBlob)
						{
							((OracleBlob)value).Dispose();
						}
						else if (value is OracleClob)
						{
							((OracleClob)value).Dispose();
						}
						else if (value is OracleBFile)
						{
							((OracleBFile)value).Dispose();
						}
						else if (m_saveValue != null)
						{
							if (m_saveValue[currentRow] is OracleBlobImpl)
							{
								((OracleBlobImpl)m_saveValue[currentRow]).RelRef();
							}
							else if (m_saveValue[currentRow] is OracleClobImpl)
							{
								((OracleClobImpl)m_saveValue[currentRow]).RelRef();
							}
							m_saveValue[currentRow] = null;
						}
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						switch (oraType)
						{
						case OraType.ORA_OCIBLobLocator:
							value = OracleBlob.Null;
							break;
						case OraType.ORA_OCICLobLocator:
							value = OracleClob.Null;
							break;
						default:
							value = OracleBFile.Null;
							break;
						}
					}
					else
					{
						value = DBNull.Value;
					}
					curSize = 0;
					status = OracleParameterStatus.NullFetched;
					return;
				}
				if (isInputOutput && value != null && m_saveValue != null)
				{
					m_saveValue[currentRow] = 0;
				}
				switch (oraType)
				{
				case OraType.ORA_OCIBLobLocator:
				{
					OracleBlob oracleBlob = value as OracleBlob;
					if (isInputOutput && oracleBlob != null && !oracleBlob.IsNull)
					{
						bool bTempLob2 = OracleBlobImpl.IsTemporaryLob(array);
						oracleBlob.SetLobLocator(array, bTempLob2);
					}
					else
					{
						value = new OracleBlob(conn, array);
					}
					if (value is OracleBlob)
					{
						((OracleBlob)value).Position = 0L;
					}
					if (PrmEnumType.ORADBTYPE != enumType)
					{
						value = (value as OracleBlob).Value;
					}
					break;
				}
				case OraType.ORA_OCICLobLocator:
				{
					OracleClob oracleClob = value as OracleClob;
					if (isInputOutput && oracleClob != null && !oracleClob.IsNull)
					{
						bool bTempLob = OracleClobImpl.IsTemporaryLob(array);
						oracleClob.SetLobLocator(array, bTempLob);
					}
					else
					{
						value = new OracleClob(conn, array, (charSetForm == 2) ? true : false, bCaching: false);
					}
					if (value is OracleClob)
					{
						((OracleClob)value).Position = 0L;
					}
					if (PrmEnumType.ORADBTYPE != enumType)
					{
						value = (value as OracleClob).Value;
					}
					break;
				}
				case OraType.ORA_OCIBFileLocator:
				{
					OracleBFile oracleBFile = value as OracleBFile;
					if (isInputOutput && oracleBFile != null && !oracleBFile.IsNull)
					{
						oracleBFile.SetLobLocator(array, bTempLob: false);
					}
					else
					{
						value = new OracleBFile(conn, array);
					}
					if (PrmEnumType.ORADBTYPE != enumType)
					{
						OracleBFile oracleBFile2 = (OracleBFile)value;
						value = oracleBFile2.GetValue();
						oracleBFile2.Dispose();
					}
					break;
				}
				}
				status = OracleParameterStatus.Success;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractLobDataFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractLobDataFromAccessor);
				}
			}
		}

		internal object GetJsonFromBytes(OracleConnection conn, Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetJsonFrombytes);
			}
			try
			{
				return ExtractJsonFromAccessor(conn, accessor, enumType, ref m_curSize, ref m_status, 0);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetJsonFrombytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetJsonFrombytes);
				}
			}
		}

		internal object GetJsonArrayFromBytes(OracleConnection conn, Accessor accessor, PrmEnumType enumType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetJsonArrayFromBytes);
			}
			Array array = null;
			try
			{
				array = (Array)((PrmEnumType.ORADBTYPE != enumType) ? ((object)new byte[bindElemCnt][]) : ((object)new OracleString[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					object obj = null;
					obj = ExtractJsonFromAccessor(conn, accessor, enumType, ref m_curArrayBindSize[i], ref m_arrayBindStatus[i], i);
					if (DBNull.Value == obj && enumType != PrmEnumType.ORADBTYPE)
					{
						array.SetValue(null, i);
					}
					else
					{
						array.SetValue(obj, i);
					}
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetJsonArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetJsonArrayFromBytes);
				}
			}
		}

		private object ExtractJsonFromAccessor(OracleConnection conn, Accessor accessor, PrmEnumType enumType, ref int curSize, ref OracleParameterStatus status, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractJsonFromAccessor);
			}
			try
			{
				TTCJsonAccessor tTCJsonAccessor = accessor as TTCJsonAccessor;
				byte[] array = null;
				if (tTCJsonAccessor != null && !tTCJsonAccessor.IsNullIndicatorSet(currentRow))
				{
					array = tTCJsonAccessor.GetLobLocator(currentRow);
				}
				if (array == null)
				{
					curSize = 0;
					status = OracleParameterStatus.NullFetched;
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						return OracleString.Null;
					}
					return DBNull.Value;
				}
				byte[] outBuffer = null;
				if (tTCJsonAccessor.m_prefetchInfo != null)
				{
					long num = tTCJsonAccessor.m_prefetchInfo.m_prefetchedDataLength[currentRow];
					if (num > 0)
					{
						outBuffer = new byte[num];
						Accessor.CopyDataToUserBuffer(tTCJsonAccessor.m_prefetchInfo.m_prefetchedData[currentRow], 0, outBuffer, 0, (int)num);
					}
				}
				else
				{
					OracleBlobImpl oracleBlobImpl = null;
					try
					{
						oracleBlobImpl = new OracleBlobImpl(conn.m_oracleConnectionImpl, array, bCaching: false);
						long length = oracleBlobImpl.GetLength();
						outBuffer = new byte[length];
						oracleBlobImpl.Read(1L, length, 0L, ref outBuffer);
					}
					catch (Exception ex)
					{
						OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractJsonFromAccessor, ex);
						throw;
					}
					finally
					{
						oracleBlobImpl.RelRef();
					}
				}
				string text = OracleJsonImpl.Decode(outBuffer);
				status = OracleParameterStatus.Success;
				if (PrmEnumType.ORADBTYPE != enumType)
				{
					return text;
				}
				return new OracleString(text);
			}
			catch (Exception ex2)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractJsonFromAccessor, ex2);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractJsonFromAccessor);
				}
			}
		}

		internal void GetXmlTypeArrayFromBytes(OracleConnection conn, Accessor accessor, PrmEnumType enumType, OraType oraType, ref object value, bool isInputOutput, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetXmlTypeArrayFromBytes);
			}
			Array array = null;
			Array array2 = null;
			try
			{
				if (isInputOutput && value != null)
				{
					array2 = value as Array;
				}
				array = new OracleXmlType[bindElemCnt];
				for (int i = 0; i < bindElemCnt; i++)
				{
					object value2 = null;
					if (array2 != null && i < array2.Length)
					{
						value2 = array2.GetValue(i);
					}
					ExtractXmlTypeDataFromAccessor(conn, accessor, enumType, oraType, ref value2, isInputOutput, ref m_curArrayBindSize[i], ref m_arrayBindStatus[i], i);
					if (DBNull.Value == value2 && enumType != PrmEnumType.ORADBTYPE)
					{
						array.SetValue(null, i);
					}
					else
					{
						array.SetValue(value2, i);
					}
				}
				value = array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetXmlTypeArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetXmlTypeArrayFromBytes);
				}
			}
		}

		private void ExtractXmlTypeDataFromAccessor(OracleConnection conn, Accessor accessor, PrmEnumType enumType, OraType oraType, ref object value, bool isInputOutput, ref int curSize, ref OracleParameterStatus status, int currentRow)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractXmlTypeDataFromAccessor);
			}
			try
			{
				TTCXmlTypeAccessor tTCXmlTypeAccessor = accessor as TTCXmlTypeAccessor;
				OraXmlTypeHeader xmlTypeHeader = new OraXmlTypeHeader();
				OraXmlTypeData xmlTypeData = null;
				if (tTCXmlTypeAccessor != null && !tTCXmlTypeAccessor.IsNullIndicatorSet(currentRow))
				{
					tTCXmlTypeAccessor.UnpickleXmlType(conn.m_oracleConnectionImpl, currentRow, xmlTypeHeader, out xmlTypeData);
				}
				if (xmlTypeData == null)
				{
					if (isInputOutput && value != null)
					{
						if (value is OracleXmlType)
						{
							((OracleXmlType)value).Dispose();
						}
						else if (value is OracleClob)
						{
							((OracleClob)value).Dispose();
						}
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						value = OracleXmlType.Null;
					}
					else
					{
						value = DBNull.Value;
					}
					curSize = 0;
					status = OracleParameterStatus.NullFetched;
				}
				else
				{
					OracleXmlType oracleXmlType = value as OracleXmlType;
					if (isInputOutput && oracleXmlType != null && !oracleXmlType.IsNull)
					{
						oracleXmlType.Set(conn, xmlTypeHeader, xmlTypeData);
					}
					else
					{
						OracleXmlTypeImpl xmlTypeImpl = new OracleXmlTypeImpl(conn.m_oracleConnectionImpl, xmlTypeHeader, xmlTypeData);
						value = new OracleXmlType(conn, xmlTypeImpl);
					}
					if (PrmEnumType.DBTYPE == enumType)
					{
						value = ((OracleXmlType)value).Value;
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractXmlTypeDataFromAccessor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.ExtractXmlTypeDataFromAccessor);
				}
			}
		}

		internal object GetTimeStampFromBytes(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampFromBytes);
			}
			try
			{
				TTCDateTimeAccessor tTCDateTimeAccessor = accessor as TTCDateTimeAccessor;
				object obj = null;
				if (tTCDateTimeAccessor != null && !tTCDateTimeAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractTimeStampFromAccessor(accessor, enumType, 0);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleTimeStamp.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampFromBytes);
				}
			}
		}

		internal object GetTimeStampLTZFromBytes(OracleConnectionImpl connImpl, Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampLTZFromBytes);
			}
			try
			{
				TTCDateTimeAccessor tTCDateTimeAccessor = accessor as TTCDateTimeAccessor;
				object obj = null;
				if (tTCDateTimeAccessor != null && !tTCDateTimeAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractTimeStampLTZFromAccessor(tTCDateTimeAccessor, enumType, connImpl, 0);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleTimeStampLTZ.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampLTZFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampLTZFromBytes);
				}
			}
		}

		internal object GetTimeStampTZFromBytes(OracleConnectionImpl connImpl, Accessor accessor, PrmEnumType enumType, bool asDateTimeOffset = false)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampTZFromBytes);
			}
			try
			{
				TTCDateTimeAccessor tTCDateTimeAccessor = accessor as TTCDateTimeAccessor;
				object obj = null;
				if (tTCDateTimeAccessor != null && !tTCDateTimeAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractTimeStampTZFromAccessor(tTCDateTimeAccessor, enumType, 0, connImpl, asDateTimeOffset);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleTimeStampTZ.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampTZFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampTZFromBytes);
				}
			}
		}

		internal object GetRawDataFromBytes(Accessor accessor, PrmEnumType enumType, int maxSize)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRawDataFromBytes);
			}
			try
			{
				TTCRawAccessor tTCRawAccessor = accessor as TTCRawAccessor;
				object obj = null;
				if (tTCRawAccessor != null && !tTCRawAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractRawFromAccessor(tTCRawAccessor, enumType, maxSize, 0, out m_curSize);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleBinary.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRawDataFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRawDataFromBytes);
				}
			}
		}

		internal object GetRawDataFromBytesInPlSqlArray(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRawDataFromBytesInPlSqlArray);
			}
			try
			{
				TTCPLSQLAssociativeArrayAccessor obj = accessor as TTCPLSQLAssociativeArrayAccessor;
				List<ArraySegment<byte>>[] plSqlAssociativeArray = obj.GetPlSqlAssociativeArray();
				int[] elementSizes = obj.GetElementSizes();
				object result = null;
				byte[][] array = null;
				OracleBinary[] array2 = null;
				if (plSqlAssociativeArray != null)
				{
					int num = plSqlAssociativeArray.Length;
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array2 = new OracleBinary[num];
						result = array2;
					}
					else
					{
						array = new byte[num][];
						result = array;
					}
					for (int i = 0; i < num; i++)
					{
						int num2 = elementSizes[i];
						if (plSqlAssociativeArray[i] != null && num2 > 0)
						{
							byte[] array3 = new byte[elementSizes[i]];
							Accessor.CopyDataToUserBuffer(plSqlAssociativeArray[i], 0, array3, 0, array3.Length);
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array2[i] = new OracleBinary(array3, bCopy: false);
							}
							else
							{
								array[i] = array3;
							}
							m_curArrayBindSize[i] = array3.Length;
							m_arrayBindStatus[i] = OracleParameterStatus.Success;
						}
						else
						{
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array2[i] = OracleBinary.Null;
							}
							m_curArrayBindSize[i] = 0;
							m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
						}
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRawDataFromBytesInPlSqlArray, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRawDataFromBytesInPlSqlArray);
				}
			}
		}

		internal object GetDecimalArrayFromBytes(Accessor accessor, PrmEnumType enumType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDecimalArrayFromBytes);
			}
			try
			{
				TTCNumberAccessor tTCNumberAccessor = accessor as TTCNumberAccessor;
				Array array = null;
				array = (Array)((PrmEnumType.ORADBTYPE != enumType) ? ((object)new decimal[bindElemCnt]) : ((object)new OracleDecimal[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCNumberAccessor != null && !tTCNumberAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractDecimalFromAccessor(accessor, enumType, i), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleDecimal.Null, i);
					}
					else
					{
						array.SetValue(0, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDecimalArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDecimalArrayFromBytes);
				}
			}
		}

		internal object GetBinaryDoubleArrayFromBytes(Accessor accessor, PrmEnumType enumType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryDoubleArrayFromBytes);
			}
			try
			{
				TTCBinaryDoubleAccessor tTCBinaryDoubleAccessor = accessor as TTCBinaryDoubleAccessor;
				Array array = null;
				array = ((PrmEnumType.ORADBTYPE != enumType) ? ((Array)new double[bindElemCnt]) : ((Array)new OracleDecimal[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCBinaryDoubleAccessor != null && !tTCBinaryDoubleAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractBDoubleFromAccessor(accessor, enumType, i), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleDecimal.Null, i);
					}
					else
					{
						array.SetValue(0, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryDoubleArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryDoubleArrayFromBytes);
				}
			}
		}

		internal object GetBinaryFloatArrayFromBytes(Accessor accessor, PrmEnumType enumType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryFloatArrayFromBytes);
			}
			try
			{
				TTCBinaryFloatAccessor tTCBinaryFloatAccessor = accessor as TTCBinaryFloatAccessor;
				Array array = null;
				array = ((PrmEnumType.ORADBTYPE != enumType) ? ((Array)new float[bindElemCnt]) : ((Array)new OracleDecimal[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCBinaryFloatAccessor != null && !tTCBinaryFloatAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractBFloatFromAccessor(accessor, enumType, i), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleDecimal.Null, i);
					}
					else
					{
						array.SetValue(0, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryFloatArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryFloatArrayFromBytes);
				}
			}
		}

		internal object GetIntArrayFromBytes(Accessor accessor, PrmEnumType enumType, OracleDbType oraDbType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntArrayFromBytes);
			}
			try
			{
				TTCNumberAccessor tTCNumberAccessor = accessor as TTCNumberAccessor;
				Array array = null;
				if (PrmEnumType.ORADBTYPE == enumType)
				{
					array = new OracleDecimal[bindElemCnt];
				}
				else
				{
					switch (oraDbType)
					{
					case OracleDbType.Byte:
						array = new byte[bindElemCnt];
						break;
					case OracleDbType.Int16:
						array = new short[bindElemCnt];
						break;
					case OracleDbType.Int32:
						array = new int[bindElemCnt];
						break;
					}
				}
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCNumberAccessor != null && !tTCNumberAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractIntFromAccessor(accessor, enumType, oraDbType, i), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleDecimal.Null, i);
					}
					else
					{
						array.SetValue(0, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntArrayFromBytes);
				}
			}
		}

		internal object GetPlsqlBooleanArrayFromBytes(Accessor accessor, PrmEnumType enumType, OracleDbType oraDbType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPlsqlBooleanArrayFromBytes);
			}
			try
			{
				TTCPLSQLBooleanAccessor tTCPLSQLBooleanAccessor = accessor as TTCPLSQLBooleanAccessor;
				Array array = null;
				array = (Array)((PrmEnumType.ORADBTYPE != enumType) ? ((object)new bool[bindElemCnt]) : ((object)new OracleBoolean[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCPLSQLBooleanAccessor != null && !tTCPLSQLBooleanAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(GetPlsqlBooleanFromBytes(accessor, enumType, oraDbType, i), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleBoolean.Null, i);
					}
					else
					{
						array.SetValue(0, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPlsqlBooleanArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPlsqlBooleanArrayFromBytes);
				}
			}
		}

		internal object GetCharArrayFromBytes(Accessor accessor, PrmEnumType enumType, byte charSetForm, int[] maxArrayBindSize, int bindElemCnt, char[] charArrayFromPooler)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetCharArrayFromBytes);
			}
			try
			{
				TTCVarcharAccessor tTCVarcharAccessor = accessor as TTCVarcharAccessor;
				Array array = null;
				array = (Array)((PrmEnumType.ORADBTYPE != enumType) ? ((object)new string[bindElemCnt]) : ((object)new OracleString[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCVarcharAccessor != null && !tTCVarcharAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractCharFromAccessor(accessor, enumType, charSetForm, maxArrayBindSize[i], i, charArrayFromPooler, out m_curArrayBindSize[i]), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleString.Null, i);
					}
					else
					{
						array.SetValue(null, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetCharArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetCharArrayFromBytes);
				}
			}
		}

		internal object GetDateArrayFromBytes(Accessor accessor, PrmEnumType enumType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDateArrayFromBytes);
			}
			try
			{
				TTCDateTimeAccessor tTCDateTimeAccessor = accessor as TTCDateTimeAccessor;
				Array array = null;
				array = ((PrmEnumType.ORADBTYPE != enumType) ? ((Array)new DateTime[bindElemCnt]) : ((Array)new OracleDate[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCDateTimeAccessor != null && !tTCDateTimeAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractDateFromAccessor(accessor, enumType, i), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleDate.Null, i);
					}
					else
					{
						array.SetValue(null, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDateArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDateArrayFromBytes);
				}
			}
		}

		internal object GetDoubleArrayFromBytes(Accessor accessor, PrmEnumType enumType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDoubleArrayFromBytes);
			}
			try
			{
				TTCNumberAccessor tTCNumberAccessor = accessor as TTCNumberAccessor;
				Array array = null;
				array = ((PrmEnumType.ORADBTYPE != enumType) ? ((Array)new double[bindElemCnt]) : ((Array)new OracleDecimal[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCNumberAccessor != null && !tTCNumberAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractDoubleFromAccessor(accessor, enumType, i), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleDecimal.Null, i);
					}
					else
					{
						array.SetValue(0, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDoubleArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDoubleArrayFromBytes);
				}
			}
		}

		internal object GetIntervalDSArrayFromBytes(Accessor accessor, PrmEnumType enumType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntervalDSArrayFromBytes);
			}
			try
			{
				TTCIntervalTypeAccessor tTCIntervalTypeAccessor = accessor as TTCIntervalTypeAccessor;
				Array array = null;
				array = (Array)((PrmEnumType.ORADBTYPE != enumType) ? ((object)new TimeSpan[bindElemCnt]) : ((object)new OracleIntervalDS[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCIntervalTypeAccessor != null && !tTCIntervalTypeAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractIntervalDSFromAccessor(accessor, enumType, i), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleIntervalDS.Null, i);
					}
					else
					{
						array.SetValue(null, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntervalDSArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntervalDSArrayFromBytes);
				}
			}
		}

		internal object GetIntervalYMArrayFromBytes(Accessor accessor, PrmEnumType enumType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntervalYMArrayFromBytes);
			}
			try
			{
				TTCIntervalTypeAccessor tTCIntervalTypeAccessor = accessor as TTCIntervalTypeAccessor;
				Array array = null;
				array = (Array)((PrmEnumType.ORADBTYPE != enumType) ? ((object)new long[bindElemCnt]) : ((object)new OracleIntervalYM[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCIntervalTypeAccessor != null && !tTCIntervalTypeAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractIntervalYMFromAccessor(accessor, enumType, i), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleIntervalYM.Null, i);
					}
					else
					{
						array.SetValue(null, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntervalYMArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntervalYMArrayFromBytes);
				}
			}
		}

		internal void GetLobArrayFromBytes(OracleConnection conn, Accessor accessor, PrmEnumType enumType, OraType oraType, ref object value, bool isInputOutput, byte charSetForm, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLobArrayFromBytes);
			}
			Array array = null;
			Array array2 = null;
			try
			{
				if (isInputOutput && value != null)
				{
					array2 = value as Array;
				}
				array = ((PrmEnumType.ORADBTYPE == enumType) ? (oraType switch
				{
					OraType.ORA_OCIBLobLocator => new OracleBlob[bindElemCnt], 
					OraType.ORA_OCICLobLocator => new OracleClob[bindElemCnt], 
					_ => new OracleBFile[bindElemCnt], 
				}) : ((oraType != OraType.ORA_OCICLobLocator) ? ((Array)new byte[bindElemCnt][]) : ((Array)new string[bindElemCnt])));
				for (int i = 0; i < bindElemCnt; i++)
				{
					object value2 = null;
					if (array2 != null && i < array2.Length)
					{
						value2 = array2.GetValue(i);
					}
					ExtractLobDataFromAccessor(conn, accessor, enumType, oraType, ref value2, isInputOutput, charSetForm, ref m_curArrayBindSize[i], ref m_arrayBindStatus[i], i);
					if (DBNull.Value == value2 && enumType != PrmEnumType.ORADBTYPE)
					{
						array.SetValue(null, i);
					}
					else
					{
						array.SetValue(value2, i);
					}
				}
				value = array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLobArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLobArrayFromBytes);
				}
			}
		}

		internal object GetLongArrayFromBytes(object accessor, PrmEnumType enumType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLongArrayFromBytes);
			}
			try
			{
				TTCNumberAccessor tTCNumberAccessor = accessor as TTCNumberAccessor;
				Array array = null;
				array = (Array)((PrmEnumType.ORADBTYPE != enumType) ? ((object)new long[bindElemCnt]) : ((object)new OracleDecimal[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCNumberAccessor != null && !tTCNumberAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractLongFromAccessor(accessor, enumType, i), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleDecimal.Null, i);
					}
					else
					{
						array.SetValue(0, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLongArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLongArrayFromBytes);
				}
			}
		}

		internal object GetRawArrayFromBytes(Accessor accessor, PrmEnumType enumType, int[] maxArrayBindSize, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRawArrayFromBytes);
			}
			try
			{
				TTCRawAccessor tTCRawAccessor = accessor as TTCRawAccessor;
				Array array = null;
				array = (Array)((PrmEnumType.ORADBTYPE != enumType) ? ((object)new byte[bindElemCnt][]) : ((object)new OracleBinary[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCRawAccessor != null && !tTCRawAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractRawFromAccessor(accessor, enumType, maxArrayBindSize[i], i, out m_curArrayBindSize[i]), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleBinary.Null, i);
					}
					else
					{
						array.SetValue(null, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRawArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRawArrayFromBytes);
				}
			}
		}

		internal object GetRefCursorArrayFromBytes(OracleConnection conn, Accessor accessor, long fetchSize, PrmEnumType enumType, OracleIntervalDS sessionTimeZone, string commandText, string paramPosOrName, long longFetchSize, long clientInitialLOBFS, long internalInitialLOBFS, long internalInitialJSONFS, long[] scnFromExecution, int bindElemCnt, bool bCallFromExecuteReader)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRefCursorArrayFromBytes);
			}
			try
			{
				TTCRefCursorAccessor tTCRefCursorAccessor = accessor as TTCRefCursorAccessor;
				Array array = null;
				array = ((!bCallFromExecuteReader && PrmEnumType.ORADBTYPE != enumType) ? ((Array)new OracleDataReader[bindElemCnt]) : ((Array)new OracleRefCursor[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCRefCursorAccessor != null && !tTCRefCursorAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractRefCursorFromAccessor(conn, accessor, fetchSize, enumType, sessionTimeZone, commandText, paramPosOrName, longFetchSize, clientInitialLOBFS, internalInitialLOBFS, internalInitialJSONFS, scnFromExecution, i, bCallFromExecuteReader), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleRefCursor.Null, i);
					}
					else
					{
						array.SetValue(null, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRefCursorArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetRefCursorArrayFromBytes);
				}
			}
		}

		internal object GetSingleArrayFromBytes(Accessor accessor, PrmEnumType enumType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetSingleArrayFromBytes);
			}
			try
			{
				TTCNumberAccessor tTCNumberAccessor = accessor as TTCNumberAccessor;
				Array array = null;
				array = ((PrmEnumType.ORADBTYPE != enumType) ? ((Array)new float[bindElemCnt]) : ((Array)new OracleDecimal[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCNumberAccessor != null && !tTCNumberAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractSingleFromAccessor(accessor, enumType, i), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleDecimal.Null, i);
					}
					else
					{
						array.SetValue(0, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetSingleArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetSingleArrayFromBytes);
				}
			}
		}

		internal object GetTimeStampArrayFromBytes(Accessor accessor, PrmEnumType enumType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampArrayFromBytes);
			}
			try
			{
				TTCDateTimeAccessor tTCDateTimeAccessor = accessor as TTCDateTimeAccessor;
				Array array = null;
				array = (Array)((PrmEnumType.ORADBTYPE != enumType) ? ((object)new DateTime[bindElemCnt]) : ((object)new OracleTimeStamp[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCDateTimeAccessor != null && !tTCDateTimeAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractTimeStampFromAccessor(accessor, enumType, i), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleTimeStamp.Null, i);
					}
					else
					{
						array.SetValue(null, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampArrayFromBytes);
				}
			}
		}

		internal object GetTimeStampLTZArrayFromBytes(OracleConnectionImpl connImpl, Accessor accessor, PrmEnumType enumType, int bindElemCnt)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampLTZArrayFromBytes);
			}
			try
			{
				TTCDateTimeAccessor tTCDateTimeAccessor = accessor as TTCDateTimeAccessor;
				Array array = null;
				array = (Array)((PrmEnumType.ORADBTYPE != enumType) ? ((object)new DateTime[bindElemCnt]) : ((object)new OracleTimeStampLTZ[bindElemCnt]));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCDateTimeAccessor != null && !tTCDateTimeAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractTimeStampLTZFromAccessor(accessor, enumType, connImpl, i), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleTimeStampLTZ.Null, i);
					}
					else
					{
						array.SetValue(null, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampLTZArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampLTZArrayFromBytes);
				}
			}
		}

		internal object GetTimeStampTZArrayFromBytes(OracleConnectionImpl connImpl, Accessor accessor, PrmEnumType enumType, int bindElemCnt, bool asDateTimeOffset = false)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampTZArrayFromBytes);
			}
			try
			{
				TTCDateTimeAccessor tTCDateTimeAccessor = accessor as TTCDateTimeAccessor;
				Array array = null;
				array = (Array)((PrmEnumType.ORADBTYPE == enumType) ? new OracleTimeStampTZ[bindElemCnt] : (asDateTimeOffset ? ((object)new DateTimeOffset[bindElemCnt]) : ((object)new DateTime[bindElemCnt])));
				for (int i = 0; i < bindElemCnt; i++)
				{
					if (tTCDateTimeAccessor != null && !tTCDateTimeAccessor.IsNullIndicatorSet(i))
					{
						array.SetValue(ExtractTimeStampTZFromAccessor(accessor, enumType, i, connImpl, asDateTimeOffset), i);
						m_arrayBindStatus[i] = OracleParameterStatus.Success;
						continue;
					}
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array.SetValue(OracleTimeStampTZ.Null, i);
					}
					else
					{
						array.SetValue(null, i);
					}
					m_curArrayBindSize[i] = 0;
					m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
				}
				return array;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampTZArrayFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetTimeStampTZArrayFromBytes);
				}
			}
		}

		internal object GetDecimalFromBytes(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDecimalFromBytes);
			}
			try
			{
				TTCNumberAccessor tTCNumberAccessor = accessor as TTCNumberAccessor;
				object obj = null;
				if (tTCNumberAccessor != null && !tTCNumberAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractDecimalFromAccessor(accessor, enumType, 0);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleDecimal.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDecimalFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDecimalFromBytes);
				}
			}
		}

		internal object GetIntFromBytes(Accessor accessor, PrmEnumType enumType, OracleDbType oraDbType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntFromBytes);
			}
			try
			{
				TTCNumberAccessor tTCNumberAccessor = accessor as TTCNumberAccessor;
				object obj = null;
				if (tTCNumberAccessor != null && !tTCNumberAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractIntFromAccessor(accessor, enumType, oraDbType, 0);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleDecimal.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntFromBytes);
				}
			}
		}

		internal object GetPlsqlBooleanFromBytes(Accessor accessor, PrmEnumType enumType, OracleDbType oraDbType, int currentRow = 0)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPlsqlBooleanFromBytes);
			}
			try
			{
				TTCPLSQLBooleanAccessor tTCPLSQLBooleanAccessor = accessor as TTCPLSQLBooleanAccessor;
				object result = null;
				if (tTCPLSQLBooleanAccessor != null)
				{
					bool? flag = (bool?)tTCPLSQLBooleanAccessor.GetBooleanValue(currentRow);
					if (flag.HasValue)
					{
						result = ((PrmEnumType.ORADBTYPE != enumType) ? ((object)flag.Value) : ((object)new OracleBoolean(flag.Value)));
						m_status = OracleParameterStatus.Success;
					}
					else
					{
						result = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleBoolean.Null));
						m_curSize = 0;
						m_status = OracleParameterStatus.NullFetched;
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPlsqlBooleanFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetPlsqlBooleanFromBytes);
				}
			}
		}

		internal object GetLongFromBytes(object accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLongFromBytes);
			}
			try
			{
				TTCNumberAccessor tTCNumberAccessor = accessor as TTCNumberAccessor;
				object obj = null;
				if (tTCNumberAccessor != null && !tTCNumberAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractLongFromAccessor(tTCNumberAccessor, enumType, 0);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleDecimal.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLongFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLongFromBytes);
				}
			}
		}

		internal object GetSingleFromBytes(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetSingleFromBytes);
			}
			try
			{
				TTCNumberAccessor tTCNumberAccessor = accessor as TTCNumberAccessor;
				object obj = null;
				if (tTCNumberAccessor != null && !tTCNumberAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractSingleFromAccessor(tTCNumberAccessor, enumType, 0);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleDecimal.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetSingleFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetSingleFromBytes);
				}
			}
		}

		internal object GetBinaryFloatFromBytes(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryFloatFromBytes);
			}
			try
			{
				TTCBinaryFloatAccessor tTCBinaryFloatAccessor = accessor as TTCBinaryFloatAccessor;
				object obj = null;
				if (tTCBinaryFloatAccessor != null && !tTCBinaryFloatAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractBFloatFromAccessor(accessor, enumType, 0);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleDecimal.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryFloatFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryFloatFromBytes);
				}
			}
		}

		internal object GetDoubleFromBytes(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDoubleFromBytes);
			}
			try
			{
				TTCNumberAccessor tTCNumberAccessor = accessor as TTCNumberAccessor;
				object obj = null;
				if (tTCNumberAccessor != null && !tTCNumberAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractDoubleFromAccessor(accessor, enumType, 0);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleDecimal.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDoubleFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDoubleFromBytes);
				}
			}
		}

		internal object GetBinaryDoubleFromBytes(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryDoubleFromBytes);
			}
			try
			{
				TTCBinaryDoubleAccessor tTCBinaryDoubleAccessor = accessor as TTCBinaryDoubleAccessor;
				object obj = null;
				if (tTCBinaryDoubleAccessor != null && !tTCBinaryDoubleAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractBDoubleFromAccessor(accessor, enumType, 0);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleDecimal.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryDoubleFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryDoubleFromBytes);
				}
			}
		}

		internal object GetDateFromBytes(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDateFromBytes);
			}
			try
			{
				object obj = null;
				TTCDateTimeAccessor tTCDateTimeAccessor = accessor as TTCDateTimeAccessor;
				if (tTCDateTimeAccessor != null && !tTCDateTimeAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractDateFromAccessor(accessor, enumType, 0);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleDate.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDateFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDateFromBytes);
				}
			}
		}

		internal object GetIntervalDSFromBytes(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntervalDSFromBytes);
			}
			try
			{
				object obj = null;
				TTCIntervalTypeAccessor tTCIntervalTypeAccessor = accessor as TTCIntervalTypeAccessor;
				if (tTCIntervalTypeAccessor != null && !tTCIntervalTypeAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractIntervalDSFromAccessor(accessor, enumType, 0);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleIntervalDS.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntervalDSFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntervalDSFromBytes);
				}
			}
		}

		internal object GetIntervalYMFromBytes(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntervalYMFromBytes);
			}
			try
			{
				object obj = null;
				TTCIntervalTypeAccessor tTCIntervalTypeAccessor = accessor as TTCIntervalTypeAccessor;
				if (tTCIntervalTypeAccessor != null && !tTCIntervalTypeAccessor.IsNullIndicatorSet(0))
				{
					obj = ExtractIntervalYMFromAccessor(accessor, enumType, 0);
					m_status = OracleParameterStatus.Success;
				}
				else
				{
					obj = ((PrmEnumType.ORADBTYPE != enumType) ? DBNull.Value : ((object)OracleIntervalYM.Null));
					m_curSize = 0;
					m_status = OracleParameterStatus.NullFetched;
				}
				return obj;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntervalYMFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetIntervalYMFromBytes);
				}
			}
		}

		internal void GetXmlTypeDataFromBytes(OracleConnection conn, Accessor accessor, PrmEnumType enumType, OraType oraType, ref object value, bool isInputOutput)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetXmlTypeDataFromBytes);
			}
			try
			{
				ExtractXmlTypeDataFromAccessor(conn, accessor, enumType, oraType, ref value, isInputOutput, ref m_curSize, ref m_status, 0);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetXmlTypeDataFromBytes, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetXmlTypeDataFromBytes);
				}
			}
		}

		internal object GetCharDataFromBytesInPLSQLArray(OracleConnectionImpl connImpl, Accessor accessor, PrmEnumType enumType, int[] elemSizesToBeReturned, byte charSetForm, char[] charArrayFromPooler)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetCharDataFromBytesInPLSQLArray);
			}
			try
			{
				TTCPLSQLAssociativeArrayAccessor obj = accessor as TTCPLSQLAssociativeArrayAccessor;
				List<ArraySegment<byte>>[] plSqlAssociativeArray = obj.GetPlSqlAssociativeArray();
				int[] elementSizes = obj.GetElementSizes();
				object result = null;
				string[] array = null;
				OracleString[] array2 = null;
				if (plSqlAssociativeArray != null)
				{
					int num = plSqlAssociativeArray.Length;
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array2 = new OracleString[num];
						result = array2;
					}
					else
					{
						array = new string[num];
						result = array;
					}
					for (int i = 0; i < num; i++)
					{
						int num2 = elementSizes[i];
						if (plSqlAssociativeArray[i] != null && num2 > 0)
						{
							if (num2 > elemSizesToBeReturned[i])
							{
								num2 = elemSizesToBeReturned[i];
							}
							string text = ((charSetForm == 2) ? connImpl.m_marshallingEngine.m_nCharSetConv.ConvertBytesToString(plSqlAssociativeArray[i], 0, num2, charArrayFromPooler) : connImpl.m_marshallingEngine.m_dbCharSetConv.ConvertBytesToString(plSqlAssociativeArray[i], 0, num2, charArrayFromPooler));
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array2[i] = new OracleString(text);
							}
							else
							{
								array[i] = text;
							}
							m_curArrayBindSize[i] = num2;
							m_arrayBindStatus[i] = OracleParameterStatus.Success;
						}
						else
						{
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array2[i] = OracleString.Null;
							}
							else
							{
								array[i] = null;
							}
							m_curArrayBindSize[i] = 0;
							m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
						}
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetCharDataFromBytesInPLSQLArray, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetCharDataFromBytesInPLSQLArray);
				}
			}
		}

		internal object GetDoubleFromBytesInPLSQLArray(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDoubleFromBytesInPLSQLArray);
			}
			try
			{
				TTCPLSQLAssociativeArrayAccessor obj = accessor as TTCPLSQLAssociativeArrayAccessor;
				List<ArraySegment<byte>>[] plSqlAssociativeArray = obj.GetPlSqlAssociativeArray();
				int[] elementSizes = obj.GetElementSizes();
				object result = null;
				OracleDecimal[] array = null;
				double[] array2 = null;
				if (plSqlAssociativeArray != null)
				{
					int num = plSqlAssociativeArray.Length;
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array = new OracleDecimal[num];
						result = array;
					}
					else
					{
						array2 = new double[num];
						result = array2;
					}
					byte[] array3 = null;
					for (int i = 0; i < num; i++)
					{
						int num2 = elementSizes[i];
						if (plSqlAssociativeArray[i] != null && num2 > 0)
						{
							if (array3 == null || array3.Length != num2)
							{
								array3 = new byte[num2];
							}
							Accessor.CopyDataToUserBuffer(plSqlAssociativeArray[i], 0, array3, 0, num2);
							double num3 = OracleNumberCore.lnxnur(array3);
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = new OracleDecimal(num3);
							}
							else
							{
								array2[i] = num3;
							}
							m_arrayBindStatus[i] = OracleParameterStatus.Success;
						}
						else
						{
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = OracleDecimal.Null;
							}
							else
							{
								array2[i] = 0.0;
							}
							m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
						}
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDoubleFromBytesInPLSQLArray, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDoubleFromBytesInPLSQLArray);
				}
			}
		}

		internal object GetSingleFromBytesInPLSQLArray(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetSingleFromBytesInPLSQLArray);
			}
			try
			{
				TTCPLSQLAssociativeArrayAccessor obj = accessor as TTCPLSQLAssociativeArrayAccessor;
				List<ArraySegment<byte>>[] plSqlAssociativeArray = obj.GetPlSqlAssociativeArray();
				int[] elementSizes = obj.GetElementSizes();
				object result = null;
				OracleDecimal[] array = null;
				float[] array2 = null;
				if (plSqlAssociativeArray != null)
				{
					int num = plSqlAssociativeArray.Length;
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array = new OracleDecimal[num];
						result = array;
					}
					else
					{
						array2 = new float[num];
						result = array2;
					}
					byte[] array3 = null;
					for (int i = 0; i < num; i++)
					{
						int num2 = elementSizes[i];
						if (plSqlAssociativeArray[i] != null && num2 > 0)
						{
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								if (array3 == null || array3.Length != num2)
								{
									array3 = new byte[num2];
								}
								Accessor.CopyDataToUserBuffer(plSqlAssociativeArray[i], 0, array3, 0, num2);
								byte[] numBytes = OracleNumberCore.lnxfpr(array3, 7);
								array[i] = new OracleDecimal(numBytes, bContainsLength: false);
							}
							else if (plSqlAssociativeArray[i].Count == 1)
							{
								ArraySegment<byte> arraySegment = plSqlAssociativeArray[i][0];
								array2[i] = HelperClass.GetFloat(arraySegment.Array, arraySegment.Offset, num2);
							}
							else
							{
								if (array3 == null || array3.Length != num2)
								{
									array3 = new byte[num2];
								}
								Accessor.CopyDataToUserBuffer(plSqlAssociativeArray[i], 0, array3, 0, num2);
								array2[i] = HelperClass.GetFloat(array3, 0, num2);
							}
							m_arrayBindStatus[i] = OracleParameterStatus.Success;
						}
						else
						{
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = OracleDecimal.Null;
							}
							else
							{
								array2[i] = 0f;
							}
							m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
						}
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetSingleFromBytesInPLSQLArray, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetSingleFromBytesInPLSQLArray);
				}
			}
		}

		internal object GetBinaryDoubleFromBytesInPLSQLArray(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryDoubleFromBytesInPLSQLArray);
			}
			try
			{
				TTCPLSQLAssociativeArrayAccessor obj = accessor as TTCPLSQLAssociativeArrayAccessor;
				List<ArraySegment<byte>>[] plSqlAssociativeArray = obj.GetPlSqlAssociativeArray();
				int[] elementSizes = obj.GetElementSizes();
				object result = null;
				OracleDecimal[] array = null;
				double[] array2 = null;
				if (plSqlAssociativeArray != null)
				{
					int num = plSqlAssociativeArray.Length;
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array = new OracleDecimal[num];
						result = array;
					}
					else
					{
						array2 = new double[num];
						result = array2;
					}
					for (int i = 0; i < num; i++)
					{
						int num2 = elementSizes[i];
						if (plSqlAssociativeArray[i] != null && num2 > 0)
						{
							byte[] array3 = new byte[8];
							Accessor.CopyDataToUserBuffer(plSqlAssociativeArray[i], 0, array3, 0, elementSizes[i]);
							double doubleFromByteArray = TTCBinaryDoubleAccessor.GetDoubleFromByteArray(array3, 0);
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = new OracleDecimal(doubleFromByteArray);
							}
							else
							{
								array2[i] = doubleFromByteArray;
							}
							m_arrayBindStatus[i] = OracleParameterStatus.Success;
						}
						else
						{
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = OracleDecimal.Null;
							}
							else
							{
								array2[i] = 0.0;
							}
							m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
						}
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryDoubleFromBytesInPLSQLArray, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryDoubleFromBytesInPLSQLArray);
				}
			}
		}

		internal object GetBinaryFloatFromBytesInPLSQLArray(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryFloatFromBytesInPLSQLArray);
			}
			try
			{
				TTCPLSQLAssociativeArrayAccessor obj = accessor as TTCPLSQLAssociativeArrayAccessor;
				List<ArraySegment<byte>>[] plSqlAssociativeArray = obj.GetPlSqlAssociativeArray();
				int[] elementSizes = obj.GetElementSizes();
				object result = null;
				OracleDecimal[] array = null;
				float[] array2 = null;
				if (plSqlAssociativeArray != null)
				{
					int num = plSqlAssociativeArray.Length;
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array = new OracleDecimal[num];
						result = array;
					}
					else
					{
						array2 = new float[num];
						result = array2;
					}
					for (int i = 0; i < num; i++)
					{
						int num2 = elementSizes[i];
						if (plSqlAssociativeArray[i] != null && num2 > 0)
						{
							byte[] array3 = new byte[4];
							Accessor.CopyDataToUserBuffer(plSqlAssociativeArray[i], 0, array3, 0, elementSizes[i]);
							float floatFromByteArray = TTCBinaryFloatAccessor.GetFloatFromByteArray(array3, 0);
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = new OracleDecimal(floatFromByteArray);
							}
							else
							{
								array2[i] = floatFromByteArray;
							}
							m_arrayBindStatus[i] = OracleParameterStatus.Success;
						}
						else
						{
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = OracleDecimal.Null;
							}
							else
							{
								array2[i] = 0f;
							}
							m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
						}
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryFloatFromBytesInPLSQLArray, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetBinaryFloatFromBytesInPLSQLArray);
				}
			}
		}

		internal object GetInt32FromBytesInPLSQLArray(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetInt32FromBytesInPLSQLArray);
			}
			try
			{
				TTCPLSQLAssociativeArrayAccessor obj = accessor as TTCPLSQLAssociativeArrayAccessor;
				List<ArraySegment<byte>>[] plSqlAssociativeArray = obj.GetPlSqlAssociativeArray();
				int[] elementSizes = obj.GetElementSizes();
				object result = null;
				OracleDecimal[] array = null;
				int[] array2 = null;
				if (plSqlAssociativeArray != null)
				{
					int num = plSqlAssociativeArray.Length;
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array = new OracleDecimal[num];
						result = array;
					}
					else
					{
						array2 = new int[num];
						result = array2;
					}
					for (int i = 0; i < num; i++)
					{
						int num2 = elementSizes[i];
						if (plSqlAssociativeArray[i] != null && num2 > 0)
						{
							byte[] array3 = new byte[elementSizes[i]];
							Accessor.CopyDataToUserBuffer(plSqlAssociativeArray[i], 0, array3, 0, array3.Length);
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = new OracleDecimal(array3, bContainsLength: false);
							}
							else
							{
								array2[i] = HelperClass.GetInt(array3, 0, array3.Length);
							}
							m_arrayBindStatus[i] = OracleParameterStatus.Success;
						}
						else
						{
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = OracleDecimal.Null;
							}
							else
							{
								array2[i] = 0;
							}
							m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
						}
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetInt32FromBytesInPLSQLArray, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetInt32FromBytesInPLSQLArray);
				}
			}
		}

		internal object GetDecimalFromBytesInPLSQLArray(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDecimalFromBytesInPLSQLArray);
			}
			try
			{
				TTCPLSQLAssociativeArrayAccessor obj = accessor as TTCPLSQLAssociativeArrayAccessor;
				List<ArraySegment<byte>>[] plSqlAssociativeArray = obj.GetPlSqlAssociativeArray();
				int[] elementSizes = obj.GetElementSizes();
				object result = null;
				OracleDecimal[] array = null;
				decimal[] array2 = null;
				if (plSqlAssociativeArray != null)
				{
					int num = plSqlAssociativeArray.Length;
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array = new OracleDecimal[num];
						result = array;
					}
					else
					{
						array2 = new decimal[num];
						result = array2;
					}
					for (int i = 0; i < num; i++)
					{
						int num2 = elementSizes[i];
						if (plSqlAssociativeArray[i] != null && num2 > 0)
						{
							byte[] array3 = new byte[elementSizes[i]];
							Accessor.CopyDataToUserBuffer(plSqlAssociativeArray[i], 0, array3, 0, array3.Length);
							if (m_precision != 100 || m_scale != 129)
							{
								OracleDecimal value = new OracleDecimal(array3, bContainsLength: false);
								OracleDecimal oracleDecimal = OracleDecimal.Null;
								if (m_precision != 100 && m_scale != 129)
								{
									oracleDecimal = OracleDecimal.ConvertToPrecScale(value, m_precision, m_scale);
								}
								else if (m_precision != 100)
								{
									oracleDecimal = OracleDecimal.SetPrecision(value, m_precision);
								}
								else if (m_scale != 129)
								{
									oracleDecimal = OracleDecimal.AdjustScale(value, m_scale, fRound: true);
								}
								if (PrmEnumType.ORADBTYPE == enumType)
								{
									array[i] = oracleDecimal;
								}
								else
								{
									array2[i] = oracleDecimal.Value;
								}
							}
							else if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = new OracleDecimal(array3, bContainsLength: false);
							}
							else
							{
								array2[i] = DecimalConv.GetDecimal(array3, 0, array3.Length);
							}
							m_arrayBindStatus[i] = OracleParameterStatus.Success;
						}
						else
						{
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = OracleDecimal.Null;
							}
							else
							{
								array2[i] = default(decimal);
							}
							m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
						}
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDecimalFromBytesInPLSQLArray, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDecimalFromBytesInPLSQLArray);
				}
			}
		}

		internal object GetLongFromBytesInPLSQLArray(object accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLongFromBytesInPLSQLArray);
			}
			try
			{
				TTCPLSQLAssociativeArrayAccessor obj = accessor as TTCPLSQLAssociativeArrayAccessor;
				List<ArraySegment<byte>>[] plSqlAssociativeArray = obj.GetPlSqlAssociativeArray();
				int[] elementSizes = obj.GetElementSizes();
				object result = null;
				OracleDecimal[] array = null;
				long[] array2 = null;
				int num = 0;
				if (plSqlAssociativeArray != null)
				{
					int num2 = plSqlAssociativeArray.Length;
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array = new OracleDecimal[num2];
						result = array;
					}
					else
					{
						array2 = new long[num2];
						result = array2;
					}
					for (int i = 0; i < num2; i++)
					{
						num = elementSizes[i];
						if (plSqlAssociativeArray[i] != null && num > 0)
						{
							byte[] array3 = new byte[num];
							Accessor.CopyDataToUserBuffer(plSqlAssociativeArray[i], 0, array3, 0, array3.Length);
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = new OracleDecimal(array3, bContainsLength: false);
							}
							else
							{
								array2[i] = OracleNumberCore.lnxsni(array3);
							}
							m_arrayBindStatus[i] = OracleParameterStatus.Success;
						}
						else
						{
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = OracleDecimal.Null;
							}
							else
							{
								array2[i] = 0L;
							}
							m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
						}
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLongFromBytesInPLSQLArray, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetLongFromBytesInPLSQLArray);
				}
			}
		}

		internal object GetDateFromBytesInPLSQLArray(Accessor accessor, PrmEnumType enumType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262400, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDateFromBytesInPLSQLArray);
			}
			try
			{
				TTCPLSQLAssociativeArrayAccessor obj = accessor as TTCPLSQLAssociativeArrayAccessor;
				List<ArraySegment<byte>>[] plSqlAssociativeArray = obj.GetPlSqlAssociativeArray();
				int[] elementSizes = obj.GetElementSizes();
				object result = null;
				OracleDate[] array = null;
				DateTime[] array2 = null;
				if (plSqlAssociativeArray != null)
				{
					int num = plSqlAssociativeArray.Length;
					if (PrmEnumType.ORADBTYPE == enumType)
					{
						array = new OracleDate[num];
						result = array;
					}
					else
					{
						array2 = new DateTime[num];
						result = array2;
					}
					for (int i = 0; i < num; i++)
					{
						int num2 = elementSizes[i];
						if (plSqlAssociativeArray[i] != null && num2 > 0)
						{
							byte[] array3 = new byte[elementSizes[i]];
							Accessor.CopyDataToUserBuffer(plSqlAssociativeArray[i], 0, array3, 0, array3.Length);
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = new OracleDate(array3);
							}
							else
							{
								array2[i] = DateTimeConv.GetDateTime(array3, OracleDbType.Date, 0, 7);
							}
							m_arrayBindStatus[i] = OracleParameterStatus.Success;
						}
						else
						{
							if (PrmEnumType.ORADBTYPE == enumType)
							{
								array[i] = OracleDate.Null;
							}
							else
							{
								array2[i] = DateTime.MinValue;
							}
							m_arrayBindStatus[i] = OracleParameterStatus.NullFetched;
						}
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDateFromBytesInPLSQLArray, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, (OracleTraceTag)262656, OracleTraceClassName.OracleParameterImpl, OracleTraceFuncName.GetDateFromBytesInPLSQLArray);
				}
			}
		}
	}
}
